Difference between Insertion sort and Selection sort

29 Mar, 2022
In this article, we will discuss the difference between the Insertion sort and the Selection sort:
Insertion sort is a simple sorting algorithm that works similar to the way you sort playing cards in your hands. The array is virtually split into a sorted and an unsorted part. Values from the unsorted part are picked and placed at the correct position in the sorted part.
Algorithm: To sort an array of size n in ascending order:  
Iterate from arr[1] to arr[n] over the array.
Compare the current element (key) to its predecessor.
If the key element is smaller than its predecessor, compare it to the elements before. Move the greater elements one position up to make space for the swapped element.
Below is the image to illustrate the Insertion Sort:  
Below is the program for the same:
C++
Java
Python3
C#
Javascript
// C++ program for the insertion sort#include <bits/stdc++.h>using namespace std; // Function to sort an array using// insertion sortvoid insertionSort(int arr[], int n){    int i, key, j;    for (i = 1; i < n; i++) {        key = arr[i];        j = i - 1;         // Move elements of arr[0..i-1],        // that are greater than key to        // one position ahead of their        // current position        while (j >= 0 && arr[j] > key) {            arr[j + 1] = arr[j];            j = j - 1;        }        arr[j + 1] = key;    }} // Function to print an array of size Nvoid printArray(int arr[], int n){    int i;     // Print the array    for (i = 0; i < n; i++) {        cout << arr[i] << " ";    }    cout << endl;} // Driver Codeint main(){    int arr[] = { 12, 11, 13, 5, 6 };    int N = sizeof(arr) / sizeof(arr[0]);     // Function Call    insertionSort(arr, N);    printArray(arr, N);     return 0;}
// Java program for the above approachimport java.util.*;class GFG{       // Function to sort an array using// insertion sortstatic void insertionSort(int arr[], int n){    int i, key, j;    for (i = 1; i < n; i++)    {        key = arr[i];        j = i - 1;         // Move elements of arr[0..i-1],        // that are greater than key to        // one position ahead of their        // current position        while (j >= 0 && arr[j] > key)        {            arr[j + 1] = arr[j];            j = j - 1;        }        arr[j + 1] = key;    }} // Function to print an array of size Nstatic void printArray(int arr[], int n){    int i;     // Print the array    for (i = 0; i < n; i++) {        System.out.print(arr[i] + " ");    }    System.out.println();}   // Driver codepublic static void main(String[] args){    int arr[] = { 12, 11, 13, 5, 6 };    int N = arr.length;     // Function Call    insertionSort(arr, N);    printArray(arr, N);}} // This code is contributed by code_hunt.
# Python 3 program for the insertion sort # Function to sort an array using# insertion sortdef insertionSort(arr, n):    i = 0    key = 0    j = 0    for i in range(1,n,1):        key = arr[i]        j = i - 1         # Move elements of arr[0..i-1],        # that are greater than key to        # one position ahead of their        # current position        while (j >= 0 and arr[j] > key):            arr[j + 1] = arr[j]            j = j - 1        arr[j + 1] = key # Function to print an array of size Ndef printArray(arr, n):    i = 0     # Print the array    for i in range(n):        print(arr[i],end = " ")    print("\n",end = "") # Driver Codeif __name__ == '__main__':    arr =  [12, 11, 13, 5, 6]    N =  len(arr)     # Function Call    insertionSort(arr, N)    printArray(arr, N)         # This code is contributed by bgangwar59.
// C# program for the above approachusing System;class GFG{     // Function to sort an array using    // insertion sort    static void insertionSort(int[] arr, int n)    {        int i, key, j;        for (i = 1; i < n; i++)        {            key = arr[i];            j = i - 1;             // Move elements of arr[0..i-1],            // that are greater than key to            // one position ahead of their            // current position            while (j >= 0 && arr[j] > key)            {                arr[j + 1] = arr[j];                j = j - 1;            }            arr[j + 1] = key;        }    }     // Function to print an array of size N    static void printArray(int[] arr, int n)    {        int i;         // Print the array        for (i = 0; i < n; i++)        {            Console.Write(arr[i] + " ");        }        Console.WriteLine();    }     // Driver code    static public void Main()    {        int[] arr = new int[] { 12, 11, 13, 5, 6 };        int N = arr.Length;         // Function Call        insertionSort(arr, N);        printArray(arr, N);    }} // This code is contributed by Dharanendra L V
<script> // JavaScript program for the above approach // Function to sort an array using// insertion sortfunction insertionSort(arr,n){    let i, key, j;    for (i = 1; i < n; i++)    {        key = arr[i];        j = i - 1;          // Move elements of arr[0..i-1],        // that are greater than key to        // one position ahead of their        // current position        while (j >= 0 && arr[j] > key)        {            arr[j + 1] = arr[j];            j = j - 1;        }        arr[j + 1] = key;    }} // Function to print an array of size Nfunction printArray(arr,n){    let i;      // Print the array    for (i = 0; i < n; i++) {        document.write(arr[i] + " ");    }    document.write("<br>");} // Driver codelet arr=[12, 11, 13, 5, 6];let N = arr.length; // Function CallinsertionSort(arr, N);printArray(arr, N);   // This code is contributed by avanitrachhadiya2155 </script>
5 6 11 12 13
 
The selection sort algorithm sorts an array by repeatedly finding the minimum element (considering ascending order) from the unsorted part and putting it at the beginning. The algorithm maintains two subarrays in a given array. 
The subarray is already sorted.
The remaining subarray is unsorted.
In every iteration of the selection sort, the minimum element (considering ascending order) from the unsorted subarray is picked and moved to the sorted subarray. 
Below is an example to explains the above steps: 
arr[] = 64 25 12 22 11

// Find the minimum element in arr[0...4]
// and place it at beginning
11 25 12 22 64

// Find the minimum element in arr[1...4]
// and place it at beginning of arr[1...4]
11 12 25 22 64

// Find the minimum element in arr[2...4]
// and place it at beginning of arr[2...4]
11 12 22 25 64

// Find the minimum element in arr[3...4]
// and place it at beginning of arr[3...4]
11 12 22 25 64 
Below is the program for the same:
C++
Java
Python3
C#
Javascript
// C++ program for implementation of// selection sort#include <bits/stdc++.h>using namespace std; // Function to swap two numbervoid swap(int* xp, int* yp){    int temp = *xp;    *xp = *yp;    *yp = temp;} // Function to implement the selection// sortvoid selectionSort(int arr[], int n){    int i, j, min_idx;     // One by one move boundary of    // unsorted subarray    for (i = 0; i < n - 1; i++) {         // Find the minimum element        // in unsorted array        min_idx = i;        for (j = i + 1; j < n; j++)            if (arr[j] < arr[min_idx])                min_idx = j;         // Swap the found minimum element        // with the first element        swap(&arr[min_idx], &arr[i]);    }} // Function to print an arrayvoid printArray(int arr[], int size){    int i;     for (i = 0; i < size; i++) {        cout << arr[i] << " ";    }    cout << endl;} // Driver Codeint main(){    int arr[] = { 64, 25, 12, 22, 11 };    int n = sizeof(arr) / sizeof(arr[0]);     // Function Call    selectionSort(arr, n);    cout << "Sorted array: \n";     // Print the array    printArray(arr, n);    return 0;}
// Java program for implementation of// selection sortimport java.util.*;class GFG{ // Function to implement the selection// sortstatic void selectionSort(int arr[], int n){    int i, j, min_idx;     // One by one move boundary of    // unsorted subarray    for (i = 0; i < n - 1; i++)    {         // Find the minimum element        // in unsorted array        min_idx = i;        for (j = i + 1; j < n; j++)            if (arr[j] < arr[min_idx])                min_idx = j;         // Swap the found minimum element        // with the first element        int temp = arr[min_idx];        arr[min_idx]= arr[i];        arr[i] = temp;    }} // Function to print an arraystatic void printArray(int arr[], int size){    int i;     for (i = 0; i < size; i++) {        System.out.print(arr[i]+ " ");    }    System.out.println();} // Driver Codepublic static void main(String[] args){    int arr[] = { 64, 25, 12, 22, 11 };    int n = arr.length;     // Function Call    selectionSort(arr, n);    System.out.print("Sorted array: \n");     // Print the array    printArray(arr, n);}} // This code is contributed by aashish1995
# Python3 program for implementation of# selection sort # Function to implement the selection# sortdef selectionSort(arr, n):     # One by one move boundary of    # unsorted subarray    for i in range(n - 1):         # Find the minimum element        # in unsorted array        min_idx = i        for j in range(i + 1, n):            if (arr[j] < arr[min_idx]):                min_idx = j         # Swap the found minimum element        # with the first element        arr[min_idx], arr[i] = arr[i], arr[min_idx] # Function to print an arraydef printArray(arr, size):     for i in range(size):        print(arr[i], end = " ")     print() # Driver Codeif __name__ == "__main__":     arr = [64, 25, 12, 22, 11]    n = len(arr)     # Function Call    selectionSort(arr, n)    print("Sorted array: ")     # Print the array    printArray(arr, n) # This code is contributed by ukasp
// C# program for implementation of// selection sortusing System;public class GFG{ // Function to implement the selection// sortstatic void selectionSort(int []arr, int n){    int i, j, min_idx;     // One by one move boundary of    // unsorted subarray    for (i = 0; i < n - 1; i++)    {         // Find the minimum element        // in unsorted array        min_idx = i;        for (j = i + 1; j < n; j++)            if (arr[j] < arr[min_idx])                min_idx = j;         // Swap the found minimum element        // with the first element        int temp = arr[min_idx];        arr[min_idx]= arr[i];        arr[i] = temp;    }} // Function to print an arraystatic void printArray(int []arr, int size){    int i;     for (i = 0; i < size; i++) {        Console.Write(arr[i]+ " ");    }    Console.WriteLine();} // Driver Codepublic static void Main(String[] args){    int []arr = { 64, 25, 12, 22, 11 };    int n = arr.Length;     // Function Call    selectionSort(arr, n);    Console.Write("Sorted array: \n");     // Print the array    printArray(arr, n);}} // This code is contributed by gauravrajput1
<script> // Javascript program for implementation of// selection sort // Function to implement the selection// sortfunction selectionSort(arr, n){    let i, j, min_idx;         // One by one move boundary of    // unsorted subarray    for(i = 0; i < n - 1; i++)    {                 // Find the minimum element        // in unsorted array        min_idx = i;                 for(j = i + 1; j < n; j++)            if (arr[j] < arr[min_idx])                min_idx = j;          // Swap the found minimum element        // with the first element        let temp = arr[min_idx];        arr[min_idx]= arr[i];        arr[i] = temp;    }} // Function to print an arrayfunction printArray(arr, size){    let i;      for(i = 0; i < size; i++)    {        document.write(arr[i] + " ");    }    document.write("<br>");} // Driver Codelet arr = [ 64, 25, 12, 22, 11 ];let n = arr.length; // Function CallselectionSort(arr, n);document.write("Sorted array: <br>"); // Print the arrayprintArray(arr, n); // This code is contributed by rag2127 </script>
Sorted array: 
11 12 22 25 64
 
Tabular Difference between Insertion Sort and Selection Sort:
 
The insertion sort is used when:
The array is has a small number of elements
There are only a few elements left to be sorted
The selection sort is used when
A small list is to be sorted
The cost of swapping does not matter
Checking of all the elements is compulsory
Cost of writing to memory matters like in flash memory (number of Swaps is O(n) as compared to O(n2) of bubble sort)
code_hunt
dharanendralv23
bgangwar59
aashish1995
GauravRajput1
ukasp
avanitrachhadiya2155
rag2127
mayank007rawa
Technical Scripter 2020
Algorithms
C++
C++ Programs
Difference Between
Sorting
Technical Scripter
Sorting
Algorithms
CPP
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
DSA Sheet by Love Babbar
SDE SHEET - A Complete Guide for SDE Preparation
What is Hashing | A Complete Tutorial
Find if there is a path between two vertices in an undirected graph
CPU Scheduling in Operating Systems
Vector in C++ STL
Map in C++ Standard Template Library (STL)
Initialize a vector in C++ (7 different ways)
std::sort() in C++ STL
Bitwise Operators in C/C++