Data Structures Tutorial

Data Structures Tutorial Asymptotic Notation Structure and Union Array Data Structure Linked list Data Structure Type of Linked list Advantages and Disadvantages of linked list Queue Data Structure Implementation of Queue Stack Data Structure Implementation of Stack Sorting Insertion sort Quick sort Selection sort Heap sort Merge sort Bucket sort Count sort Radix sort Shell sort Tree Traversal of the binary tree Binary search tree Graph Spanning tree Linear Search Binary Search Hashing Collision Resolution Techniques

Misc Topic:

Priority Queue in Data Structure Deque in Data Structure Difference Between Linear And Non Linear Data Structures Queue Operations In Data Structure About Data Structures Data Structures Algorithms Types of Data Structures Big O Notations Introduction to Arrays Introduction to 1D-Arrays Operations on 1D-Arrays Introduction to 2D-Arrays Operations on 2D-Arrays Strings in Data Structures String Operations Application of 2D array Bubble Sort Insertion Sort Sorting Algorithms What is DFS Algorithm What Is Graph Data Structure What is the difference between Tree and Graph What is the difference between DFS and BFS Bucket Sort Dijkstra’s vs Bellman-Ford Algorithm Linear Queue Data Structure in C Stack Using Array Stack Using Linked List Recursion in Fibonacci Stack vs Array What is Skewed Binary Tree Primitive Data Structure in C Dynamic memory allocation of structure in C Application of Stack in Data Structures Binary Tree in Data Structures Heap Data Structure Recursion - Factorial and Fibonacci What is B tree what is B+ tree Huffman tree in Data Structures Insertion Sort vs Bubble Sort Adding one to the number represented an array of digits Bitwise Operators and their Important Tricks Blowfish algorithm Bubble Sort vs Selection Sort Hashing and its Applications Heap Sort vs Merge Sort Insertion Sort vs Selection Sort Merge Conflicts and ways to handle them Difference between Stack and Queue AVL tree in data structure c++ Bubble sort algorithm using Javascript Buffer overflow attack with examples Find out the area between two concentric circles Lowest common ancestor in a binary search tree Number of visible boxes putting one inside another Program to calculate the area of the circumcircle of an equilateral triangle Red-black Tree in Data Structures Strictly binary tree in Data Structures 2-3 Trees and Basic Operations on them Asynchronous advantage actor-critic (A3C) Algorithm Bubble Sort vs Heap Sort Digital Search Tree in Data Structures Minimum Spanning Tree Permutation Sort or Bogo Sort Quick Sort vs Merge Sort

Insertion Sort in Data Structures

Insertion Sort in C++

Insertion sort is a sorting algorithm that, in each iteration, installs an unsorted element in its proper position

Insertion sort operates in a similar way to how we sort cards in a card game.

We collect an unsorted card deck and we presume that the first card is already sorted that is, it is the smallest number of all. If the next card is larger than the one in hand, it goes behind; otherwise, it comes to the front. Similarly, other unordered cards are collected and Placed in the mannered way.

Insertion sort takes a similar strategy.


In order to sort an array of n elements in increasing order, use the following commands:

  mark first element as sorted
  for each unsorted element X
    'extract' the element X
    for j <- lastSortedIndex down to 0
      if current element j > X
        move sorted element to the right by 1
    break loop and insert X here
end insertionSort

Insertion Sort's Operation

Consider using the array given below as an example for understanding how insertion sort works.

  • The array's initial element is presumed to be sorted. Select the second value and place it in another key.
  • Make a comparison between the first value and the key. In case the first value is bigger than key, the value is placed in front of key.
Insertion Sort in C++
  • The first two items have now been sorted.
  • Now consider the third element in relation to the components on its left and place it just before the element that it is smaller than. So, placing it at the start of the array as there are no elements smaller as compared to key element.
Insertion Sort in C++

Similarly, put each unsorted element in its proper location.

Insertion Sort in C++

Code for Insertion Sort in c++

// Insertion sort in C++

#include <iostream>
using namespace std;

// Function for print an array
void printArray(int array[], int size) {
  for (int i = 0; i < size; i++) {
    cout << array[i] << " ";
  cout << endl;

void insertionSort(int array[], int size) {
  for (int step = 1; step < size; step++) {
    int key = array[step];
    int j = step - 1;

    // Compare key with each element on the left of it until an element smaller than
    // it is found.
    // For descending order, change key<array[j] to key>array[j].
    while (key < array[j] && j >= 0) {
      array[j + 1] = array[j];
    array[j + 1] = key;

// Main code
int main() {
  int data[] = {11, 9, 6, 41, 32};
  int size = sizeof(data) / sizeof(data[0]);
  insertionSort(data, size);
  cout << "Sorted array in ascending order:\n";
  printArray(data, size);


Sorted array in ascending order:
6 9 11 32 41

Complexity for Insertion Sort

Time Complexity
Best CaseO(n)
Worst CaseO(n2)
Space ComplexityO(1)

Complexities of Time

  • Complexity in the worst-case scenario: O (n2)

Let's consider having an array that is sorted in ascending order and that is to be sorted in descending order. In this situation, worst case complexity happens.

Each and every element is to be compared to each of the other elements, resulting in a (n-1) number of comparisons for every nth element.

As a result, the total number of comparisons is equal to n*(n-1) n2.

  • Complexity in the Best-Case Scenario: O (n)

When the array has already been sorted, the outer loop repeats n times, but the inner loop does not. As a result, there are only n possible comparisons. As a result, complexity follows a linear pattern.

  • Case Complexity on the Average: O (n2)

When the items of an array are jumbled together, this happens (neither ascending nor descending).

Complexity of Space

Because an additional variable key is employed, the space complexity is O(1).

Applications for Insertion Sorting

The insertion sort is used in the following situations:

  • When only a few elements in the array are to be sorted.
  • When there are only a few components are left to sort.

What is Binary Insertion Sort, and how does it work?

In conventional insertion sort, we may employ binary search to minimize the number of comparisons. At each cycle, Binary Insertion Sort employs binary search to identify the right spot to insert the selected item. In the worst scenario, sorting in regular insertion takes O(n) (at nth iteration). Binary search implementation, can decrease the complexity up to O(log n). Because of the multiple swapping that are necessary for each insertion, the method as a whole still has a worst-case time complexity as O(n2).