Skip to main content

Function to sort an array using insertion sort

Insertion sort is slightly better sorting method among O(n2) algorithms. It is effecient if the elements are almost sorted and if the size is small.

Insertion sort basically works by splitting your elements into two parts. Sorted half and unsorted half. To begin with, Sorted half is empty and unsorted half has all elements. Then one element is removed from unsorted half and added to the sorted half. When adding , this element is inserted at the correct location. This process is continued till we have all the elements in sorted half and unsorted half is empty. Now let us try to understand it with a diagram.
First 17 is removed from unsorted array and added to sorted array. Since there is one element there, it is sorted. Next 4 which is front most element now in unsored array is removed and added to sorted array. But 4 is smaller than 17, so 17 is pushed to right and its place is taken by 4.
   Next 32 is removed from the front of unsorted array and added to sorted array. But here in sorted array to last element 17 is smaller. So 32 is in its correct place. Next 1 is moved from front of unsorted array. In sorted array, 32 is larger and pushed to right. Next 17 is pushed to right and 4 is also pushed to right. Now 1 is placed in 4's position. As you can see, now these 4 elements are sorted. This process continues until all the elements are removed from unsorted array.
   Removing front most element from the array takes O(1) X N elements. And inserting an element takes in worst case O(N) time. Hence complexity is O(N2 ) .
C++ function to insertion sort an array is really very simple and small.

#include<iostream>
using std::cin;
using std::cout;

void insertionSort(int *arr,int size);
void printArray(int *arr,int size);
int main()
{
    int n;
    cout<<"Size of array:";
    cin>>n;
    int a[n];
    cout<<"Elements of array:";
    for(int i=0;i<size;i++)
         cin>>a[i];
     insertionSort(a,n);
     printArray(a,n);
     return 0;
}

void insertionSort(int *arr,int size)
{
   for(int i=1;i<size;i++)
   {
        int val = arr[i];
        int j;
        for(j=i-1;j>=0 && arr[j] >val;j--)
        {
                 arr[j+1]=arr[j];
         }
         arr[j+1]=val;
   }
}


void printArray(int *arr,int size)
{
     for(int i=0;i<size;i++) 
            cout<< arr[i]<<"=====";
 
 }

In the insertionSort function, outer loop is for extracting one element from unsorted array. And inner loop is for inserting it in the sorted array and pushing elements to right as needed.
Writing insertion sort for linked list is much simple as well. You take one more linked list - sortedList. Now remove front element from list and insert it in ascending order in sortedList.
Labels:

Comments

Post a Comment

Popular posts from this blog

In order traversal of nodes in the range x to y

Question : Write a function for in-order traversal of nodes in the range x to y from a binary search tree. This is quite a simple function. As a first solution we can just traverse our binary search tree in inorder and display only the nodes which are in the range x to y. But if the current node has a value less than x, do we have to traverse its left subtree? No. Because all the nodes in left subtree will be smaller than x. Similarly if the current node has a key value more than y, we need not visit its right subtree. Now we are ready to write our algorithm.     if nd is NOT NULL  if nd->val >=x then visit all the nodes of left subtree of nd recursively display nd->val if nd->val <y then visit all the nodes of right subtree of nd recursively  That's all. We have our function ready. void in_order_middle (NODEPTR nd, int x, int y) { if (nd) { if (nd -> val >= x) in_order_middle(nd...
Post a Comment
Read more

Josephus problem

Question: Write a function to delete every k th node from circular linked list until only one node is left. This has a story associated with it. Flavius Josephus was Jewish Historian from 1st century. He and 40 other soldiers were trapped in a cave by Romans. They decided to kill themselves rather than surrendering to Romans. Their method was like this. All the soldiers will stand in a circle and every k th soldier will be shot dead. Josephus said to have calculated the starting point so that he would remain alive. So we have similar problem at hand. We delete every kth node in a circular list. Eventually only one node will be left. e.g. Let us say this is our list And we are deleting every third node.  We will delete 30. Then we delete 60. Next we delete 10. Next it will be 50. Next to be deleted is 20. Next 80. This continues. Implementation   We can count k-1 nodes and delete next node. This can be repeated in  a loop. What must be the termina...
Post a Comment
Read more

Lowest common ancestor of binary search tree

Question : Write a function to print the lowest common ancestor of two nodes in a binary search tree.  Lowest common ancestor of two nodes x and y in a binary tree is the lowest node that has both x and y as descendants. Here lowest common ancestor of 1 and 7 is 3. LCA of 13 and 7 is root - 8. And LCA of 6 and 7 is 6 itself. The program to find gets complicated for an ordinary binary tree. But for a binary search tree, it is quite simple. As we see from the diagram above, the paths to 1 and 4 are common till the node 3. And at 3 they branch in different directions. So 3 is our LCA. That is lowest common ancestor is the node where the paths to x and y from root deviate. As long as they branch in same direction, we continue to traverse. When they branch in different directions, that is the lowest common ancestor. So let us write a simple algorithm, set temp=root if temp->val >x and temp->val>y temp = temp->left else if temp->val<x and ...
Post a Comment
Read more