Skip to content
Related Articles

Related Articles

Improve Article

Difference between Insertion sort and Selection sort

  • Last Updated : 24 Jun, 2021
Geek Week

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: 
 

insertion-sort



Below is the program for the same:

C++




// C++ program for the insertion sort
#include <bits/stdc++.h>
using namespace std;
 
// Function to sort an array using
// insertion sort
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
void printArray(int arr[], int n)
{
    int i;
 
    // Print the array
    for (i = 0; i < n; i++) {
        cout << arr[i] << " ";
    }
    cout << endl;
}
 
// Driver Code
int 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




// Java program for the above approach
import java.util.*;
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++) {
        System.out.print(arr[i] + " ");
    }
    System.out.println();
}
   
// Driver code
public 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.

Python3




# Python 3 program for the insertion sort
 
# Function to sort an array using
# insertion sort
def 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 N
def printArray(arr, n):
    i = 0
 
    # Print the array
    for i in range(n):
        print(arr[i],end = " ")
    print("\n",end = "")
 
# Driver Code
if __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#




// C# program for the above approach
using 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

Javascript




<script>
 
// JavaScript program for the above approach
 
// Function to sort an array using
// insertion sort
function 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 N
function printArray(arr,n)
{
    let i;
  
    // Print the array
    for (i = 0; i < n; i++) {
        document.write(arr[i] + " ");
    }
    document.write("<br>");
}
 
// Driver code
let arr=[12, 11, 13, 5, 6];
let N = arr.length;
 
// Function Call
insertionSort(arr, N);
printArray(arr, N);
 
 
 
// This code is contributed by avanitrachhadiya2155
 
</script>
Output: 
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.
  • Remaining subarray which 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 the 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++




// C++ program for implementation of
// selection sort
#include <bits/stdc++.h>
using namespace std;
 
// Function to swap two number
void swap(int* xp, int* yp)
{
    int temp = *xp;
    *xp = *yp;
    *yp = temp;
}
 
// Function to implement the selection
// sort
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
        swap(&arr[min_idx], &arr[i]);
    }
}
 
// Function to print an array
void printArray(int arr[], int size)
{
    int i;
 
    for (i = 0; i < size; i++) {
        cout << arr[i] << " ";
    }
    cout << endl;
}
 
// Driver Code
int 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




// Java program for implementation of
// selection sort
import java.util.*;
class GFG
{
 
// Function to implement the selection
// sort
static 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 array
static void printArray(int arr[], int size)
{
    int i;
 
    for (i = 0; i < size; i++) {
        System.out.print(arr[i]+ " ");
    }
    System.out.println();
}
 
// Driver Code
public 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




# Python3 program for implementation of
# selection sort
 
# Function to implement the selection
# sort
def 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 array
def printArray(arr, size):
 
    for i in range(size):
        print(arr[i], end = " ")
 
    print()
 
# Driver Code
if __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#




// C# program for implementation of
// selection sort
using System;
public class GFG
{
 
// Function to implement the selection
// sort
static 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 array
static void printArray(int []arr, int size)
{
    int i;
 
    for (i = 0; i < size; i++) {
        Console.Write(arr[i]+ " ");
    }
    Console.WriteLine();
}
 
// Driver Code
public 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

Javascript




<script>
 
// Javascript program for implementation of
// selection sort
 
// Function to implement the selection
// sort
function 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 array
function printArray(arr, size)
{
    let i;
  
    for(i = 0; i < size; i++)
    {
        document.write(arr[i] + " ");
    }
    document.write("<br>");
}
 
// Driver Code
let arr = [ 64, 25, 12, 22, 11 ];
let n = arr.length;
 
// Function Call
selectionSort(arr, n);
document.write("Sorted array: <br>");
 
// Print the array
printArray(arr, n);
 
// This code is contributed by rag2127
 
</script>
Output: 
Sorted array: 
11 12 22 25 64

 

Tabular Difference between Insertion Sort and Selection Sort:

 

Insertion SortSelection Sort
1.Inserts the value in the presorted array to sort the set of values in the array.Finds the minimum / maximum number from the list and sort it in ascending / descending order.
2.It is a stable sorting algorithm.It is an unstable sorting algorithm.
3. The best-case time complexity is O(N) when the array is already in ascending order.There is no best case the time complexity is O(N2) in all cases.
4.The number of comparison operations performed in this sorting algorithm is less than the swapping performed.The number of comparison operations performed in this sorting algorithm is more than the swapping performed.
5. It is more efficient than the Selection sort.It is less efficient than the Insertion sort.
6. Here the element is known beforehand, and we search for the correct position to place them.The location where to put the element is previously known we search for the element to insert at that position.

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.




My Personal Notes arrow_drop_up
Recommended Articles
Page :