{"id":122895,"date":"2020-05-01T09:56:59","date_gmt":"2020-05-01T09:56:59","guid":{"rendered":"https:\/\/www.softwaretestinghelp.com\/?page_id=122895"},"modified":"2025-04-01T08:30:35","modified_gmt":"2025-04-01T08:30:35","slug":"selection-sort-java","status":"publish","type":"page","link":"https:\/\/www.softwaretestinghelp.com\/selection-sort-java\/","title":{"rendered":"Selection Sort In Java – Selection Sort Algorithm & Examples"},"content":{"rendered":"

This Tutorial will Explain all about Selection Sort In Java along with Selection Sort Algorithm, Java Code, Implementation in Java and Java Examples:<\/strong><\/p>\n

The selection sort technique is a method in which the smallest element in the array is selected and swapped with the first element of the array. Next, the second smallest element in the array is exchanged with the second element and vice versa.<\/p>\n

=> Check Here To See A-Z Of Java Training Tutorials Here.<\/a><\/strong><\/p>\n

<\/strong><\/em><\/p>\n

\"Selection<\/a><\/p>\n

Selection Sort In Java<\/h2>\n

This way the smallest element in the array is selected repeatedly and put in its proper position until the entire array is sorted.<\/p>\n

Two sub-arrays are maintained for selection sort:<\/strong><\/p>\n

    \n
  1. Sorted sub-array:<\/strong> In every iteration, the minimum element is found and placed in its proper position. This sub-array is sorted.<\/li>\n
  2. Unsorted sub-array:<\/strong> The remaining elements that are not sorted.<\/li>\n<\/ol>\n

    The selection sort is a straightforward and easy sorting technique. The technique only involves finding the smallest element in every pass and placing it in the correct position. The selection sort is ideal for smaller data sets as it sorts the smaller dataset efficiently.<\/p>\n

    Thus we can say selection sort is not advisable for larger lists of data.<\/p>\n

    Selection Sort Algorithm<\/h3>\n

    The General Algorithm for Selection Sort is given below:<\/strong><\/p>\n

    Selection Sort (A, N)<\/strong><\/span><\/p>\n

    Step 1<\/strong>: Repeat Steps 2 and 3 for K = 1 to N-1<\/p>\n

    Step 2<\/strong>: Call routine smallest(A, K, N, POS)<\/p>\n

    Step 3<\/strong>:<\/p>\n

    Swap A[K] with A [POS]
    \n[End of loop]<\/p>\n

    Step 4<\/strong>: EXIT<\/p>\n

    Routine smallest (A, K, N, POS)<\/strong><\/span><\/p>\n

    Step 1<\/strong>: [initialize] set smallestItem = A[K]<\/p>\n

    Step 2<\/strong>: [initialize] set POS = K<\/p>\n

    Step 3<\/strong>:<\/p>\n

    for J = K+1 to N -1, repeat
    \nif smallestItem > A [J]
    \nset smallestItem = A [J]
    \nset POS = J
    \n[if end]
    \n[End of loop]<\/p>\n

    Step 4<\/strong>: return POS<\/p>\n

    As you can see, the routine to find the smallest number is called while traversing the data set. Once the smallest element is found, it is placed in its desired position.<\/p>\n

    Pseudocode For Selection Sort<\/h3>\n

    The pseudo-code for the selection sort algorithm is given below.<\/strong><\/p>\n

    Procedure selection_sort(array,N)\r\n\tarray \u2013 array of items to be sorted\r\n\tN \u2013 size of array\r\nbegin\r\n\tfor I = 1 to N-1\r\n\tbegin\r\n\t\tset min  = i\r\n\t\tfor j = i+1 to N\r\n\t\tbegin\r\n\t\t\tif array[j] < array[min] then\r\n\t\t\t\tmin = j;\r\n\t\t\tend if\r\n\t\tend for\r\n\t\t\/\/swap the minimum element with current element\r\n\t\tif minelem != I then\r\n\t\t\tswap array[min[] and array[i]\r\n\t\tend if\r\n\tend for\r\nend procedure<\/pre>\n
    Let us now illustrate the sorting of an array using selection sort.<\/p>\n
    Selection Sort Example<\/h3>\n
    Consider the following array that is to be sorted as an example of a selection sort.<\/strong><\/span><\/p>\n
    \"Selection<\/a><\/p>\n
    \"Pass<\/a><\/p>\n
    \"Pass<\/a><\/p>\n
    \"Pass<\/a><\/p>\n
    \"Pass<\/a><\/p>\n
    Given below is a tabular representation for the illustration:<\/strong><\/p>\n\n
    \n\n\n\n\t\n\n\t\n\t\n\t\n\t\n\t\n\t
    Unsorted list<\/th>Least element<\/th>Sorted list<\/th>\n<\/tr>\n<\/thead>\n
    {17,10,7,29,2}<\/td>2<\/td>{}<\/td>\n<\/tr>\n
    {17,10,7,29}<\/td>7<\/td>{2}<\/td>\n<\/tr>\n
    {17,10,29}<\/td>10<\/td>{2,7}<\/td>\n<\/tr>\n
    {17,29}<\/td>17<\/td>{2,7,10)<\/td>\n<\/tr>\n
    {29}<\/td>29<\/td>{2,7,10,17}<\/td>\n<\/tr>\n
    {}<\/td><\/td>{2,7,10,17,29}<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n\n
    From the illustration, we see that with every pass the next smallest element is put in its correct position in the sorted array. In general, to sort an array of N elements, we need N-1 passes in total.<\/p>\n
    Selection Sort Implementation In Java<\/h3>\n
    Let’s now demonstrate the Java program to implement selection sort.<\/strong><\/p>\n
    import java.util.*;\r\nclass Main \r\n{ \r\n    static void sel_sort(int numArray[]) \r\n    { \r\n        int n = numArray.length; \r\n  \r\n        \/\/ traverse unsorted array \r\n        for (int i = 0; i < n-1; i++) \r\n        { \r\n            \/\/ Find the minimum element in unsorted array \r\n            int min_idx = i; \r\n            for (int j = i+1; j < n; j++) \r\n                if (numArray[j] < numArray[min_idx]) \r\n                    min_idx = j; \r\n  \r\n            \/\/ swap minimum element with compared element  \r\n            int temp = numArray[min_idx]; \r\n            numArray[min_idx] = numArray[i]; \r\n            numArray[i] = temp; \r\n        } \r\n    } \r\n  \r\n    public static void main(String args[]) \r\n    { \r\n        \/\/declare and print the original array\r\n        int numArray[] = {7,5,2,20,42,15,23,34,10};\r\n        System.out.println("Original Array:" + Arrays.toString(numArray)); \r\n        \/\/call selection sort routine\r\n        sel_sort(numArray); \r\n        \/\/print the sorted array\r\n        System.out.println("Sorted Array:" + Arrays.toString(numArray)); \r\n    } \r\n} \r\n<\/pre>\n
    Output:<\/strong><\/p>\n
    Original Array:[7, 5, 2, 20, 42, 15, 23, 34, 10]
    \nSorted Array:[2, 5, 7, 10, 15, 20, 23, 34, 42]<\/p>\n
    \"Output<\/a><\/p>\n
    In the above java example, we repeatedly find the smallest element in the array and put it in the sorted array until the entire array is completely sorted.<\/p>\n
    Selection Sort Linked List In Java<\/h3>\n
    Given below is a linked list and we have to sort it using selection sort. To do this we will use the recursive approach of selection sort. Instead of swapping the data part of the node, we will swap the nodes and realign the pointers.<\/p>\n
    So if the linked list is given as follows:<\/strong><\/p>\n
    \"linked<\/a><\/p>\n
    \"linked<\/a><\/p>\n
    Given below is the Java program that implements the above sorting.<\/strong><\/p>\n
    \/\/ add a node to the beginning of the linked list \r\nstatic Node addNode( Node head_ref, int new_data)  \r\n{  \r\n    \/\/ create a node  \r\n    Node newNode = new Node();  \r\n  \r\n    \/\/ assign data to node  \r\n    newNode.data = new_data;  \r\n  \r\n    \/\/ link the node to linked list \r\n    newNode.next = (head_ref);  \r\n  \r\n    \/\/head now points to new node  \r\n    (head_ref) = newNode;  \r\n    return head_ref; \r\n}  \r\n\/\/ method to swap nodes  \r\nstatic Node swapNodes( Node head_ref, Node curr_node1,  Node curr_node2, Node prev_node) {  \r\n    \/\/ curr_node2 is new head \r\n    head_ref = curr_node2;  \r\n    \/\/ realign links\r\n    prev_node.next = curr_node1;  \r\n  \r\n    \/\/ now swap next pointers of nodes  \r\n    Node temp = curr_node2.next;  \r\n    curr_node2.next = curr_node1.next;  \r\n    curr_node1.next = temp;  \r\n    return head_ref; \r\n}  \r\n  \r\n\/\/ sort the linked list using selection sort  \r\nstatic Node Selection_Sort( Node head) {  \r\n    \/\/ only a single node in linked list  \r\n    if (head.next == null)  \r\n        return head;  \r\n  \r\n    \/\/ minNode => node with minimum data value  \r\n    Node minNode = head;  \r\n  \r\n    \/\/ prevMin => node previous to minNode \r\n    Node prevMin = null;  \r\n    Node ptr;  \r\n  \r\n    \/\/ traverse the list from head to last node  \r\n    for (ptr = head; ptr.next != null; ptr = ptr.next)   {  \r\n          \/\/ check if current node is minimum \r\n        if (ptr.next.data < minNode.data)   {  \r\n            minNode = ptr.next;  \r\n            prevMin = ptr;  \r\n        }  \r\n    }  \r\n    \/\/ minimum node becomes head now\r\n    if (minNode != head)  \r\n        head = swapNodes(head, head, minNode, prevMin);  \r\n  \r\n    \/\/ sort remaning list recursively  \r\n    head.next = Selection_Sort(head.next);  \r\n  \r\n    return head;  \r\n}  \r\n\/\/ sort the given linked list  \r\nstatic Node sort( Node head_ref)  \r\n{  \r\n    \/\/ linked list is empty  \r\n    if ((head_ref) == null)  \r\n        return null;  \r\n  \r\n    \/\/ call Selection_Sort method to sort the linked list  \r\n    head_ref = Selection_Sort(head_ref);  \r\n    return head_ref; \r\n}  \r\n  \r\n\/\/ print nodes of linked list  \r\nstatic void printList( Node head)  \r\n{  \r\n    while (head != null)  \r\n    {  \r\n        System.out.print( head.data + " ");  \r\n        head = head.next;  \r\n    }  \r\n}  \r\n  \r\npublic static void main(String args[]) \r\n{  \r\n    Node oddList = null;  \r\n  \r\n    \/\/ create linked list using addNode method  \r\n    oddList = addNode(oddList, 11);  \r\n    oddList = addNode(oddList, 1);  \r\n    oddList = addNode(oddList, 5);  \r\n    oddList = addNode(oddList, 3);  \r\n    oddList = addNode(oddList, 9); \r\n    oddList = addNode(oddList, 7);\r\n    \/\/print the original list\r\n    System.out.println( "Original Linked list:");  \r\n    printList(oddList);  \r\n  \r\n    \/\/ sort the linked list  \r\n    oddList = sort(oddList);  \r\n  \r\n    \/\/print the sorted list\r\n    System.out.println( "\\nLinked list after sorting:");  \r\n    printList(oddList);  \r\n}  \r\n}  \r\n<\/pre>\n
    Output:<\/strong><\/p>\n
    Original Linked list:
    \n7 9 3 5 1 11
    \nLinked list after sorting:
    \n1 3 5 7 9 11<\/p>\n
    \"Implementing<\/a><\/p>\n
    Note that in the above program, we have realigned links of the nodes instead of sorting only the data component of the node.<\/p>\n
    Frequently Asked Questions<\/h3>\n
    Q #1) How does Selection sort work?<\/strong><\/span><\/p>\n
    Answer:<\/strong> Selection sort works by maintaining two sub-arrays. The minimum element from the unsorted subarray is placed in its proper position in a sorted sub-array. Then the second-lowest element is placed in its proper position. This way, the entire array is sorted by selecting a minimum element during each iteration.<\/p>\n
    Q #2) <\/span><\/strong>What is the complexity of the Selection sort?<\/strong><\/span><\/p>\n
    Answer:<\/strong> The overall complexity of selection sort is O (n2<\/sup>), thereby making it the algorithm that is inefficient on larger data sets. Other sorting techniques are more efficient.<\/p>\n
    Q #3) <\/span><\/strong>What are the Advantages and Disadvantages of Selection sort?<\/strong><\/span><\/p>\n
    Answer:<\/strong> Selection sort is the in-place sorting technique and thus it does not require additional storage to store intermediate elements.<\/p>\n
    It works efficiently on smaller data structures as well as the data sets that are almost sorted.<\/p>\n
    The major disadvantage of the selection sort technique is that it performs very poorly as the size of the data structure increases. It not only becomes slower but also decreases efficiency.<\/p>\n
    Q #4) <\/span><\/strong>How many swaps are there in the Selection sort?<\/strong><\/span><\/p>\n
    Answer:<\/strong> The selection sort technique takes the minimum number of swaps. For the best case, when the array is sorted, the number of swaps in the selection sort is 0.<\/p>\n
    Q #5) <\/span><\/strong>Is selection sort faster than Insertion sort?<\/strong><\/span><\/p>\n
    Answer:<\/strong> Insertion sort is faster and more efficient as well as stable. Selection sort is faster only for smaller data sets and partially sorted structures.<\/p>\n
    Conclusion<\/h2>\n
    Selection sort is a technique that works by selecting the minimum element while traversing the array. For each pass\/iteration, the next minimum element in the data set is selected and placed in its proper position.<\/p>\n
    The selection sort technique works efficiently when the number of elements in the data set is smaller, but it starts to perform poorly as the size of the data set grows. It becomes inefficient when compared to the other similar techniques like insertion sort.<\/p>\n
    In this tutorial, we have implemented examples to sort arrays and linked lists using selection sort.\u00a0<\/strong><\/em><\/p>\n
    => Visit Here To See The Java Training Series For All.<\/a><\/strong><\/p>\n\r\n\t\t\t
    \r\n\r\n\t\t\t\t
    \r\n\t\t\t\t\t
    \r\n\t\t\t\t\t\t
    Was this helpful?<\/h3>\r\n\t\t\t\t\t<\/div>\r\n\t\t\t\t\t
    \r\n\t\t\t\t\t\t
    \r\n\t\t\t\t\t\t\t\r\n\t\t\t
    \r\n\t\t\t\t\r\n                \r\n                    \r\n                        
    \r\n\t\t\t\t\r\n                \r\n                    \r\n                        
    \r\n\t\t\t\t\t
    \r\n\t\t\t\t\t\t