Iterative selection sort for linked list

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:

  1. By swapping the data parts of the nodes.
  2. 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.

filter_none

edit
close

play_arrow

link
brightness_4
code

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;
    }
}

chevron_right


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 :

  1. Nodes are adjacent and the first node is the starting node.
  2. Nodes are adjacent and the first node isn’t the starting node.
  3. Nodes aren’t adjacent and the first node is the starting node.
  4. Nodes aren’t adjacent and the first node isn’t the starting node.

Below is the implementation of the above approach:

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ implementation of the approach
#include <bits/stdc++.h>
using namespace std;
  
// Linked List Node
struct Node {
    int data;
    Node* next;
};
  
// Utility function to create a
// new Linked List Node
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
Node* 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 list
void printList(Node* head)
{
    while (head) {
        cout << head->data << " ";
        head = head->next;
    }
}
  
// Driver Code
int main()
{
    Node* head = newNode(5);
    head->next = newNode(4);
    head->next->next = newNode(3);
  
    head = selectionSort(head);
  
    printList(head);
  
    return 0;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java implementation of the approach
class 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

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# Python3 implementation of the approach 
  
# Linked List Node 
class 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 pointers 
def 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 =
  
                        # Swap b and d pointers 
                        b, d = d, b 
                        c =
  
                        # Update the head 
                        head =
  
                        # 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 =
                        a.next =
  
                        # Swap b and d pointers 
                        b, d = d, b 
                        c =
  
                        # 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 =
                        c.next =
  
                        # Swap b and d pointers 
                        b, d = d, b 
                        c =
  
                        # Skip to the next element 
                        # as it is already in order 
                        d = d.next
  
                        # Update the head 
                        head =
                      
                    # 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 =
                        c.next =
                        a.next =
  
                        # Swap b and d pointers 
                        b, d = d, b 
                        c =
  
                        # 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.next
  
        a =
        b = b.next
      
    return head 
  
# Function to print the list 
def printList(head): 
  
    while head: 
        print(head.data, end = " "
        head = head.next
  
# Driver Code 
if __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

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# implementation of the approach
using 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

chevron_right


Output:

3 4 5


My Personal Notes arrow_drop_up

Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.