 GFG App
Open App Browser
Continue

# 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.

## C++

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

## Java

 `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 `

## C#

 `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 `

## Javascript

 ``

## Python3

 `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 :

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++

 `// C++ implementation of the approach ` `#include ` `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; ` `} `

## Java

 `// 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 `

## Python3

 `# 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` `=` `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 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 `

## C#

 `// 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 `

## Javascript

 ``

Output:

`3 4 5`

My Personal Notes arrow_drop_up