Iterative selection sort for linked list - GeeksforGeeks

21 Jun, 2021
Given a linked list, the task is to sort the linked list in ascending order by using selection sort.Examples:  
Input : 1->4->2->2->3
Output : 1->2->2->3->4

Input : 5->4->3->2
Output : 2->3->4->5
 
Selection Sort Algorithm: Iterate the given list N times where N is the number of elements in the list. In every iteration of selection sort, the minimum element (considering ascending order) from the unsorted subarray is picked and moved to the sorted subarray.Example:  
list = 64 25 12 22 11

// Find the minimum element in list(0...4)
// and place it at beginning
11 25 12 22 64

// Find the minimum element in list(1...4)
// and place it at beginning of list(1...4)
11 12 25 22 64

// Find the minimum element in list(2...4)
// and place it at beginning of list(2...4)
11 12 22 25 64

// Find the minimum element in list(3...4)
// and place it at beginning of list(3...4)
11 12 22 25 64 
The swapping required can be done in two ways:  
By swapping the data parts of the nodes.By swapping the complete nodes.
By swapping the data parts of the nodes.
By swapping the complete nodes.
Second implementation is generally used when elements of the list are some kind of records because in such a case data swapping becomes tedious and expensive due to the presence of a large number of data elements.Implementation Method 1: Below is the implementation of selection sort function for sorting linked lists by swapping only data parts of a node.  
C++
Java
C#
Javascript
Python3
void selectionSort(node* head){    node* temp = head;     // Traverse the List    while (temp) {        node* min = temp;        node* r = temp->next;         // Traverse the unsorted sublist        while (r) {            if (min->data > r->data)                min = r;             r = r->next;        }         // Swap Data        int x = temp->data;        temp->data = min->data;        min->data = x;        temp = temp->next;    }}
void selectionSort(node head){    node temp = head;     // Traverse the List    while (temp) {        node min = temp;        node r = temp.next;         // Traverse the unsorted sublist        while (r) {            if (min.data > r.data)                min = r;             r = r.next;        }         // Swap Data        int x = temp.data;        temp.data = min.data;        min.data = x;        temp = temp.next;    }} // This code is contributed by shivanisinghss2110
static void selectionSort(node head){    node temp = head;     // Traverse the List    while (temp) {        node min = temp;        node r = temp.next;         // Traverse the unsorted sublist        while (r) {            if (min.data > r.data)                min = r;             r = r.next;        }         // Swap Data        int x = temp.data;        temp.data = min.data;        min.data = x;        temp = temp.next;    }}// This code contributed by shivanisinghss2110
<script>  function selectionSort(head){    var temp = head;     // Traverse the List    while (temp) {        var min = temp;        var r = temp.next;         // Traverse the unsorted sublist        while (r) {            if (min.data > r.data)                min = r;             r = r.next;        }         // Swap Data        var x = temp.data;        temp.data = min.data;        min.data = x;        temp = temp.next;    }} </script>
def selectionSort(head):         temp = head         # Traverse the List    while (temp):                 minn = temp        r = temp.next                 # Traverse the unsorted sublist        while (r):            if (minn.data > r.data):                minn = r                         r = r.next                     # Swap Data        x = temp.data        temp.data = minn.data        minn.data = x        temp = temp.next     # This code is contributed by shubhamsingh10
Method 2: Data swapping is no doubt easier to implement and understand, but in some cases( as one mentioned above ), it isn’t desirable. While doing swapping of the next parts of two nodes, four cases are needed to be taken into consideration :  
Nodes are adjacent and the first node is the starting node.Nodes are adjacent and the first node isn’t the starting node.Nodes aren’t adjacent and the first node is the starting node.Nodes aren’t adjacent and the first node isn’t the starting node.
Nodes are adjacent and the first node is the starting node.
Nodes are adjacent and the first node isn’t the starting node.
Nodes aren’t adjacent and the first node is the starting node.
Nodes aren’t adjacent and the first node isn’t the starting node.
Below is the implementation of the above approach:  
C++
Java
Python3
C#
Javascript
// C++ implementation of the approach#include <bits/stdc++.h>using namespace std; // Linked List Nodestruct Node {    int data;    Node* next;}; // Utility function to create a// new Linked List NodeNode* newNode(int val){    Node* temp = new Node;     temp->data = val;     temp->next = NULL;     return temp;} // Function to sort a linked list using selection// sort algorithm by swapping the next pointersNode* selectionSort(Node* head){    Node *a, *b, *c, *d, *r;     a = b = head;     // While b is not the last node    while (b->next) {         c = d = b->next;         // While d is pointing to a valid node        while (d) {             if (b->data > d->data) {                 // If d appears immediately after b                if (b->next == d) {                     // Case 1: b is the head of the linked list                    if (b == head) {                         // Move d before b                        b->next = d->next;                        d->next = b;                         // Swap b and d pointers                        r = b;                        b = d;                        d = r;                         c = d;                         // Update the head                        head = b;                         // Skip to the next element                        // as it is already in order                        d = d->next;                    }                     // Case 2: b is not the head of the linked list                    else {                         // Move d before b                        b->next = d->next;                        d->next = b;                        a->next = d;                         // Swap b and d pointers                        r = b;                        b = d;                        d = r;                         c = d;                         // Skip to the next element                        // as it is already in order                        d = d->next;                    }                }                 // If b and d have some non-zero                // number of nodes in between them                else {                     // Case 3: b is the head of the linked list                    if (b == head) {                         // Swap b->next and d->next                        r = b->next;                        b->next = d->next;                        d->next = r;                        c->next = b;                         // Swap b and d pointers                        r = b;                        b = d;                        d = r;                         c = d;                         // Skip to the next element                        // as it is already in order                        d = d->next;                         // Update the head                        head = b;                    }                     // Case 4: b is not the head of the linked list                    else {                         // Swap b->next and d->next                        r = b->next;                        b->next = d->next;                        d->next = r;                        c->next = b;                        a->next = d;                         // Swap b and d pointers                        r = b;                        b = d;                        d = r;                         c = d;                         // Skip to the next element                        // as it is already in order                        d = d->next;                    }                }            }            else {                 // Update c and skip to the next element                // as it is already in order                c = d;                d = d->next;            }        }         a = b;        b = b->next;    }     return head;} // Function to print the listvoid printList(Node* head){    while (head) {        cout << head->data << " ";        head = head->next;    }} // Driver Codeint main(){    Node* head = newNode(5);    head->next = newNode(4);    head->next->next = newNode(3);     head = selectionSort(head);     printList(head);     return 0;}
// Java implementation of the approachclass GFG {     // Linked List Node    static class Node {        int data;        Node next;    };     // Utility function to create a    // new Linked List Node    static Node newNode(int val)    {        Node temp = new Node();         temp.data = val;         temp.next = null;         return temp;    }     // Function to sort a linked list using selection    // sort algorithm by swapping the next pointers    static Node selectionSort(Node head)    {        Node a, b, c, d, r;         a = b = head;         // While b is not the last node        while (b.next != null) {             c = d = b.next;             // While d is pointing to a valid node            while (d != null) {                 if (b.data > d.data) {                     // If d appears immediately after b                    if (b.next == d) {                         // Case 1: b is the head of the linked list                        if (b == head) {                             // Move d before b                            b.next = d.next;                            d.next = b;                             // Swap b and d pointers                            r = b;                            b = d;                            d = r;                             c = d;                             // Update the head                            head = b;                             // Skip to the next element                            // as it is already in order                            d = d.next;                        }                         // Case 2: b is not the head of the linked list                        else {                             // Move d before b                            b.next = d.next;                            d.next = b;                            a.next = d;                             // Swap b and d pointers                            r = b;                            b = d;                            d = r;                             c = d;                             // Skip to the next element                            // as it is already in order                            d = d.next;                        }                    }                     // If b and d have some non-zero                    // number of nodes in between them                    else {                         // Case 3: b is the head of the linked list                        if (b == head) {                             // Swap b.next and d.next                            r = b.next;                            b.next = d.next;                            d.next = r;                            c.next = b;                             // Swap b and d pointers                            r = b;                            b = d;                            d = r;                             c = d;                             // Skip to the next element                            // as it is already in order                            d = d.next;                             // Update the head                            head = b;                        }                         // Case 4: b is not the head of the linked list                        else {                             // Swap b.next and d.next                            r = b.next;                            b.next = d.next;                            d.next = r;                            c.next = b;                            a.next = d;                             // Swap b and d pointers                            r = b;                            b = d;                            d = r;                             c = d;                             // Skip to the next element                            // as it is already in order                            d = d.next;                        }                    }                }                else {                     // Update c and skip to the next element                    // as it is already in order                    c = d;                    d = d.next;                }            }             a = b;            b = b.next;        }         return head;    }     // Function to print the list    static void printList(Node head)    {        while (head != null) {            System.out.print(head.data + " ");            head = head.next;        }    }     // Driver Code    public static void main(String args[])    {        Node head = newNode(5);        head.next = newNode(4);        head.next.next = newNode(3);         head = selectionSort(head);         printList(head);    }} // This code is contributed by Arnab Kundu
# Python3 implementation of the approach # Linked List Nodeclass Node:         def __init__(self, val):        self.data = val        self.next = None # Function to sort a linked list# using selection sort algorithm# by swapping the next pointersdef selectionSort(head):     a = b = head     # While b is not the last node    while b.next:         c = d = b.next         # While d is pointing to a valid node        while d:             if b.data > d.data:                 # If d appears immediately after b                if b.next == d:                     # Case 1: b is the head                    # of the linked list                    if b == head:                         # Move d before b                        b.next = d.next                        d.next = b                         # Swap b and d pointers                        b, d = d, b                        c = d                         # Update the head                        head = b                         # Skip to the next element                        # as it is already in order                        d = d.next                                         # Case 2: b is not the head                    # of the linked list                    else:                         # Move d before b                        b.next = d.next                        d.next = b                        a.next = d                         # Swap b and d pointers                        b, d = d, b                        c = d                         # Skip to the next element                        # as it is already in order                        d = d.next                                     # If b and d have some non-zero                # number of nodes in between them                else:                     # Case 3: b is the head                    # of the linked list                    if b == head:                         # Swap b.next and d.next                        r = b.next                        b.next = d.next                        d.next = r                        c.next = b                         # Swap b and d pointers                        b, d = d, b                        c = d                         # Skip to the next element                        # as it is already in order                        d = d.next                         # Update the head                        head = b                                         # Case 4: b is not the head                    # of the linked list                    else:                         # Swap b.next and d.next                        r = b.next                        b.next = d.next                        d.next = r                        c.next = b                        a.next = d                         # Swap b and d pointers                        b, d = d, b                        c = d                         # Skip to the next element                        # as it is already in order                        d = d.next                                 else:                 # Update c and skip to the next element                # as it is already in order                c = d                d = d.next         a = b        b = b.next         return head # Function to print the listdef printList(head):     while head:        print(head.data, end = " ")        head = head.next # Driver Codeif __name__ == "__main__":     head = Node(5)    head.next = Node(4)    head.next.next = Node(3)     head = selectionSort(head)     printList(head) # This code is contributed# by Rituraj Jain
// C# implementation of the approachusing System; class GFG {     // Linked List Node    public class Node {        public int data;        public Node next;    };     // Utility function to create a    // new Linked List Node    static Node newNode(int val)    {        Node temp = new Node();         temp.data = val;         temp.next = null;         return temp;    }     // Function to sort a linked list using selection    // sort algorithm by swapping the next pointers    static Node selectionSort(Node head)    {        Node a, b, c, d, r;         a = b = head;         // While b is not the last node        while (b.next != null) {             c = d = b.next;             // While d is pointing to a valid node            while (d != null) {                 if (b.data > d.data) {                     // If d appears immediately after b                    if (b.next == d) {                         // Case 1: b is the head of the linked list                        if (b == head) {                             // Move d before b                            b.next = d.next;                            d.next = b;                             // Swap b and d pointers                            r = b;                            b = d;                            d = r;                             c = d;                             // Update the head                            head = b;                             // Skip to the next element                            // as it is already in order                            d = d.next;                        }                         // Case 2: b is not the head of the linked list                        else {                             // Move d before b                            b.next = d.next;                            d.next = b;                            a.next = d;                             // Swap b and d pointers                            r = b;                            b = d;                            d = r;                             c = d;                             // Skip to the next element                            // as it is already in order                            d = d.next;                        }                    }                     // If b and d have some non-zero                    // number of nodes in between them                    else {                         // Case 3: b is the head of the linked list                        if (b == head) {                             // Swap b.next and d.next                            r = b.next;                            b.next = d.next;                            d.next = r;                            c.next = b;                             // Swap b and d pointers                            r = b;                            b = d;                            d = r;                             c = d;                             // Skip to the next element                            // as it is already in order                            d = d.next;                             // Update the head                            head = b;                        }                         // Case 4: b is not the head of the linked list                        else {                             // Swap b.next and d.next                            r = b.next;                            b.next = d.next;                            d.next = r;                            c.next = b;                            a.next = d;                             // Swap b and d pointers                            r = b;                            b = d;                            d = r;                             c = d;                             // Skip to the next element                            // as it is already in order                            d = d.next;                        }                    }                }                else {                     // Update c and skip to the next element                    // as it is already in order                    c = d;                    d = d.next;                }            }             a = b;            b = b.next;        }         return head;    }     // Function to print the list    static void printList(Node head)    {        while (head != null) {            Console.Write(head.data + " ");            head = head.next;        }    }     // Driver Code    public static void Main(String[] arg)    {        Node head = newNode(5);        head.next = newNode(4);        head.next.next = newNode(3);         head = selectionSort(head);         printList(head);    }} // This code contributed by Rajput-Ji
<script>// Javascript implementation of the approach // Structure of a node of linked listclass Node {        constructor() {                this.data = 0;                this.next = null;             }        }         // Utility function to create a// new Linked List Nodefunction newNode( val){    var temp = new Node();    temp.data = val;    temp.next = null;    return temp;} // Function to sort a linked list using selection// sort algorithm by swapping the next pointersfunction selectionSort( head)    {        var a, b, c, d, r;         a = b = head;         // While b is not the last node        while (b.next != null) {             c = d = b.next;             // While d is pointing to a valid node            while (d != null) {                 if (b.data > d.data) {                     // If d appears immediately after b                    if (b.next == d) {                         // Case 1: b is the head of the linked list                        if (b == head) {                             // Move d before b                            b.next = d.next;                            d.next = b;                             // Swap b and d pointers                            r = b;                            b = d;                            d = r;                             c = d;                             // Update the head                            head = b;                             // Skip to the next element                            // as it is already in order                            d = d.next;                        }                         // Case 2: b is not the head of the linked list                        else {                             // Move d before b                            b.next = d.next;                            d.next = b;                            a.next = d;                             // Swap b and d pointers                            r = b;                            b = d;                            d = r;                             c = d;                             // Skip to the next element                            // as it is already in order                            d = d.next;                        }                    }                     // If b and d have some non-zero                    // number of nodes in between them                    else {                         // Case 3: b is the head of the linked list                        if (b == head) {                             // Swap b.next and d.next                            r = b.next;                            b.next = d.next;                            d.next = r;                            c.next = b;                             // Swap b and d pointers                            r = b;                            b = d;                            d = r;                             c = d;                             // Skip to the next element                            // as it is already in order                            d = d.next;                             // Update the head                            head = b;                        }                         // Case 4: b is not the head of the linked list                        else {                             // Swap b.next and d.next                            r = b.next;                            b.next = d.next;                            d.next = r;                            c.next = b;                            a.next = d;                             // Swap b and d pointers                            r = b;                            b = d;                            d = r;                             c = d;                             // Skip to the next element                            // as it is already in order                            d = d.next;                        }                    }                }                else {                     // Update c and skip to the next element                    // as it is already in order                    c = d;                    d = d.next;                }            }             a = b;            b = b.next;        }         return head;    } // Function to print the listfunction printList( head){    while (head != null) {        document.write(head.data + " ");        head = head.next;    }}     // Driver Code    var head = newNode(5);    head.next = newNode(4);    head.next.next = newNode(3);    head = selectionSort(head);    printList(head); // This code is contributed by jana_sayantan.</script>
3 4 5
 
andrew1234
rituraj_jain
Rajput-Ji
SHUBHAMSINGH10
shivanisinghss2110
jana_sayantan
rrrtnx
selection-sort
Linked List
Sorting
Linked List
Sorting
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
LinkedList in Java
Linked List vs Array
Doubly Linked List | Set 1 (Introduction and Insertion)
Merge two sorted linked lists
Queue - Linked List Implementation