Insertion Sort by Swapping Elements
Last Updated :
22 Dec, 2022
Insertion Sort is suitable for arrays of small size. It also achieves the best-case complexity of O(n) if the arrays are already sorted. We have discussed both Iterative Insertion Sort and Recursive Insertion Sort. In this article, slightly different implementations for both iterative and recursive versions are discussed.
Iterative Insertion Sort:
Let us look at the algorithm for the iterative insertion sort
function insertionSort(V)
i, j, k
for i from 1..length(V)
k = V[i]
j = i-1
while j > 0 and k < V[j]
V[j+1] = V[j]
j -= 1
V[j] = k
return V
Inside the while loop, we shift all values larger than k by one position and then insert k into the first position where k is larger than the array value. The same effect is obtained if we swap consecutive array elements. By repeated swapping, k will travel to its correct position.
Let’s take an example to illustrate this
Insert 3 in A = {1, 2, 4, 5, 6}
Put 3 at the end of list.
A = {1, 2, 4, 5, 6, 3}
3 < 6, swap 3 and 6
A = {1, 2, 4, 5, 3, 6}
3 < 5 swap 3 and 5
A = {1, 2, 4, 3, 5, 6}
3 < 4 swap 3 and 4
A = {1, 2, 3, 4, 5, 6}
3 > 2 so stop
By repeatedly swapping 3 travels to its proper position in the list
Therefore the above algorithm can be modified as
function insertionSort(V)
for i in 1...length(V)
j = i
while ( j > 0 and V[j] < V[j-1])
Swap V[j] and V[j-1]
j -= 1
return V
The CPP code for this algorithm is given below
Implementation:
C++
#include <iostream>
#include <vector>
using namespace std;
using Vector = vector<int>;
void printVector(const Vector& V)
{
for (auto e : V) {
cout << e << " ";
}
cout << endl;
}
void insertionSort(Vector& V)
{
int N = V.size();
int i, j, key;
for (i = 1; i < N; i++) {
j = i;
while (j > 0 and V[j] < V[j - 1]) {
swap(V[j], V[j - 1]);
j -= 1;
}
}
}
int main()
{
Vector A = { 9, 8, 7, 5, 2, 1, 2, 3 };
cout << "Array: " << endl;
printVector(A);
cout << "After Sorting :" << endl;
insertionSort(A);
printVector(A);
return 0;
}
|
Java
import java.io.*;
import java.util.*;
class GFG
{
static void printVector( Vector<Integer> V)
{
for (int i = 0; i < V.size(); i++) {
System.out.print(V.get(i)+" ");
}
System.out.println();
}
static void insertionSort(Vector<Integer> V)
{
int N = V.size();
int i, j, key;
for (i = 1; i < N; i++) {
j = i;
while (j > 0 && V.get(j) < V.get(j - 1)) {
int temp= V.get(j);
V.set(j, V.get(j - 1));
V.set(j - 1, temp);
j -= 1;
}
}
}
public static void main (String[] args)
{
Vector<Integer> A = new Vector<Integer> ();
A.add(0, 9);
A.add(1, 8);
A.add(2, 7);
A.add(3, 5);
A.add(4, 2);
A.add(5, 1);
A.add(6, 2);
A.add(7, 3);
System.out.print("Array: ");
printVector(A);
System.out.print("After Sorting :");
insertionSort(A);
printVector(A);
}
}
|
Python3
import math
def printVector( V):
for i in V:
print(i ,end= " ")
print (" ")
def insertionSort( V):
N = len(V)
for i in range(1,N):
j = i
while (j > 0 and V[j] < V[j - 1]) :
temp = V[j];
V[j] = V[j - 1];
V[j-1] = temp;
j -= 1
A = [ 9, 8, 7, 5, 2, 1, 2, 3 ]
n = len(A)
print("Array")
printVector(A)
print( "After Sorting :")
insertionSort(A)
printVector(A)
|
C#
using System;
using System.Collections.Generic;
class GFG
{
static void printVector(List<int> V)
{
for (int i = 0; i < V.Count; i++)
{
Console.Write(V[i] + " ");
}
Console.WriteLine();
}
static void insertionSort(List<int> V)
{
int N = V.Count;
int i, j;
for (i = 1; i < N; i++)
{
j = i;
while (j > 0 && V[j] < V[j - 1])
{
int temp= V[j];
V[j] = V[j - 1];
V[j - 1] = temp;
j -= 1;
}
}
}
public static void Main (String[] args)
{
List<int> A = new List<int> ();
A.Insert(0, 9);
A.Insert(1, 8);
A.Insert(2, 7);
A.Insert(3, 5);
A.Insert(4, 2);
A.Insert(5, 1);
A.Insert(6, 2);
A.Insert(7, 3);
Console.Write("Array: \n");
printVector(A);
Console.Write("After Sorting :\n");
insertionSort(A);
printVector(A);
}
}
|
Javascript
<script>
function printVector(V) {
for (let e of V) {
document.write(e + " ");
}
document.write("<br>");
}
function insertionSort(V) {
let N = V.length;
let i, j, key;
for (i = 1; i < N; i++) {
j = i;
while (j > 0 && V[j] < V[j - 1]) {
let temp = V[j];
V[j] = V[j - 1];
V[j - 1] = temp;
j -= 1;
}
}
}
let A = [9, 8, 7, 5, 2, 1, 2, 3];
document.write("Array: " + "<br>");
printVector(A);
document.write("After Sorting :" + "<br>");
insertionSort(A);
printVector(A);
</script>
|
Output
Array:
9 8 7 5 2 1 2 3
After Sorting :
1 2 2 3 5 7 8 9
Time Complexity: O(N*N)
Auxiliary Space: O(1)
Recursive Insertion Sort:
Consider an Array A of size N
- First recursively sort the sublist of A which is of size N-1
- Insert the last element of A into the sorted sublist.
To perform the insertion step use repeated swapping as discussed above.
Algorithm:
function insertionSortRecursive(A, N)
if N >= 1
insertionSortRecursive(A, N-1)
j = N-1
while j > 0 and A[j] < A[j-1]
Swap A[j] and A[j-1]
j = j-1
[end of while]
[end of if]
Following is the implementation of the above approach:
C++
#include <iostream>
#include <vector>
using namespace std;
using Vector = vector<int>;
void printVector(const Vector& V)
{
for (auto e : V) {
cout << e << " ";
}
cout << endl;
}
void insertionSortRecursive(Vector& V, int N)
{
if (N <= 1)
return;
insertionSortRecursive(V, N - 1);
int j = N - 1;
while (j > 0 and V[j] < V[j - 1]) {
swap(V[j], V[j - 1]);
j -= 1;
}
}
int main()
{
Vector A = { 9, 8, 7, 5, 2, 1, 2, 3 };
cout << "Array: " << endl;
printVector(A);
cout << "After Sorting :" << endl;
insertionSortRecursive(A, A.size());
printVector(A);
return 0;
}
|
Java
import java.io.*;
import java.util.*;
class GFG
{
static void printVector( Vector<Integer> V)
{
for (int i = 0; i < V.size(); i++) {
System.out.print(V.get(i) + " ");
}
System.out.println();
}
static void insertionSortRecursive(Vector<Integer> V,int N)
{
if (N <= 1)
return;
insertionSortRecursive(V, N - 1);
int j = N - 1;
while (j > 0 && V.get(j) < V.get(j - 1))
{
int temp= V.get(j);
V.set(j, V.get(j - 1));
V.set(j - 1, temp);
j -= 1;
}
}
public static void main (String[] args)
{
Vector<Integer> A = new Vector<Integer> ();
A.add(0, 9);
A.add(1, 8);
A.add(2, 7);
A.add(3, 5);
A.add(4, 2);
A.add(5, 1);
A.add(6, 2);
A.add(7, 3);
System.out.print("Array: ");
printVector(A);
System.out.print("After Sorting :");
insertionSortRecursive(A,A.size());
printVector(A);
}
}
|
Python3
import math
def printVector( V):
for i in V:
print(i, end = " ")
print (" ")
def insertionSortRecursive(V, N):
if (N <= 1):
return 0
insertionSortRecursive(V, N - 1)
j = N - 1
while (j > 0 and V[j] < V[j - 1]) :
temp = V[j];
V[j] = V[j - 1];
V[j-1] = temp;
j -= 1
A = [ 9, 8, 7, 5, 2, 1, 2, 3 ]
n=len(A)
print("Array")
printVector(A)
print( "After Sorting :")
insertionSortRecursive(A,n)
printVector(A)
|
C#
using System;
using System.Collections.Generic;
class GFG
{
static void printVector(List<int> V)
{
for (int i = 0; i < V.Count; i++)
{
Console.Write(V[i] + " ");
}
Console.WriteLine();
}
static void insertionSortRecursive(List<int> V,
int N)
{
if (N <= 1)
return;
insertionSortRecursive(V, N - 1);
int j = N - 1;
while (j > 0 && V[j] < V[j - 1])
{
int temp = V[j];
V[j] = V[j - 1];
V[j - 1] = temp;
j -= 1;
}
}
public static void Main (String[] args)
{
List<int> A = new List<int> ();
A.Insert(0, 9);
A.Insert(1, 8);
A.Insert(2, 7);
A.Insert(3, 5);
A.Insert(4, 2);
A.Insert(5, 1);
A.Insert(6, 2);
A.Insert(7, 3);
Console.Write("Array: ");
printVector(A);
Console.Write("After Sorting :");
insertionSortRecursive(A, A.Count);
printVector(A);
}
}
|
Javascript
<script>
function printVector(V) {
for (let e of V) {
document.write(e + " ");
}
document.write("<br>");
}
function insertionSortRecursive(V, N) {
if (N <= 1)
return;
insertionSortRecursive(V, N - 1);
let j = N - 1;
while (j > 0 && V[j] < V[j - 1]) {
let temp = V[j];
V[j] = V[j - 1];
V[j - 1] = temp;
j -= 1;
}
}
let A = [9, 8, 7, 5, 2, 1, 2, 3];
document.write("Array: <br>");
printVector(A);
document.write("After Sorting :<br>");
insertionSortRecursive(A, A.length);
printVector(A);
</script>
|
Output
Array:
9 8 7 5 2 1 2 3
After Sorting :
1 2 2 3 5 7 8 9
Note: The Time Complexity of the algorithm is still O(N^2) in the worst case. Moreover, these versions are potentially slower since repeated swapping requires more operations. However, these versions are discussed because of their implementation simplicity and ease of understanding.
Similar Reads
Insertion Sort by Swapping Elements
Insertion Sort is suitable for arrays of small size. It also achieves the best-case complexity of O(n) if the arrays are already sorted. We have discussed both Iterative Insertion Sort and Recursive Insertion Sort. In this article, slightly different implementations for both iterative and recursive
11 min read
Sort 1 to N by swapping adjacent elements
Given an array, A of size N consisting of elements 1 to N. A boolean array B consisting of N-1 elements indicates that if B[i] is 1, then A[i] can be swapped with A[i+1]. Find out if A can be sorted by swapping elements. Examples: Input : A[] = {1, 2, 5, 3, 4, 6} B[] = {0, 1, 1, 1, 0}Output : A can
15+ min read
Insertion sort using C++ STL
Implementation of Insertion Sort using STL functions. Pre-requisites : Insertion Sort, std::rotate, std::upper_bound, C++ Iterators. The idea is to use std::upper_bound to find an element making the array unsorted. Then we can rotate the unsorted part so that it ends up sorted. We can traverse the a
1 min read
Inserting Elements in an Array | Array Operations
In this post, we will look into insertion operation in an Array, i.e., how to insert into an Array, such as: Insert Element at the Beginning of an ArrayInsert Element at a given position in an ArrayInsert Element at the End of an ArrayInsert Element at the Beginning of an ArrayInserting an element a
2 min read
Binary Insertion Sort
Binary insertion sort is a sorting algorithm which is similar to the insertion sort, but instead of using linear search to find the location where an element should be inserted, we use binary search. Thus, we reduce the comparative value of inserting a single element from O (N) to O (log N). It is a
15+ min read
Time and Space Complexity of Insertion Sort
What is Insertion Sort?Insertion sort is a simple sorting algorithm that works similarly 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 in the correct position in the sorted part. T
2 min read
Insertion Sort Algorithm
Insertion sort is a simple sorting algorithm that works by iteratively inserting each element of an unsorted list into its correct position in a sorted portion of the list. It is like sorting playing cards in your hands. You split the cards into two groups: the sorted cards and the unsorted cards. T
9 min read
Count swaps required to sort an array using Insertion Sort
Given an array A[] of size N (1 ≤ N ≤ 105), the task is to calculate the number of swaps required to sort the array using insertion sort algorithm. Examples: Input: A[] = {2, 1, 3, 1, 2} Output: 4 Explanation: Step 1: arr[0] stays in its initial position. Step 2: arr[1] shifts 1 place to the left. C
15 min read
Sort decreasing permutation of N using triple swaps
Given an array A[] consisting of decreasing permutation of N numbers, the task is to sort the array using triple swaps. If it is not possible to sort the array then print -1. Triple swaps refer to cyclic right shift on chosen indices. Cyclic Right Shift: x --> y --> z --> x. Examples: Input
7 min read
String conversion by swapping adjacent characters
Given two strings, A and B, both consisting of uppercase alphabets. You can perform the following operation any number of times: choose any index i in string A and swap A[i] with either A[i+k] or A[i+k+1], where k is a positive integer, the task is to determine if it is possible to convert string A
8 min read