C EXAMPLE : SHELL SORT

SOURCE CODE :
===============================================================

#include <stdio.h>
#include <conio.h>
#define MAX 20

void main()
{
 int arr[MAX],i,j,k,n,increment;
 clrscr();
 printf("\n==============Example of Shell Sort ==============\n");
 printf("\nEnter the number of elements: ");
 scanf("%d",&n);
 printf("\nEnter %d elements : \n",n);
 for(i=0 ; i<n ; i++)
 scanf("%d",&arr[i]);

 printf("\nUnsorted list is:\n");
 for (i = 0; i < n; i++)
 {
  printf("%4d",arr[i]);
 }
 increment=5;

 /*ACTUAL LOGIC STARTS*/

 while(increment>=1)
 {
  for(j=increment ; j<n ; j++)
  {
   k=arr[j];
   for(i = j-increment ; i >= 0 && k<arr[i] ; i = i-increment)
   arr[i+increment]=arr[i];
   arr[i+increment]=k;
  }
  increment=increment-2;  /*Decrease the incrementement*/
 }
 printf("\n\nSorted list is:\n");
 for (i = 0 ; i<n ; i++)
 {
  printf("%4d",arr[i]);
 }
 getch();
}

 ===============================================================  

 OUTPUT:

C EXAMPLE : COUNT SORT

SOURCE CODE :
===============================================================

#include<stdio.h>
#include<conio.h>
int Counting_sort(int A[], int k, int n)
{
    int i, j;
    int B[15], C[100];
    for(i = 0; i <= k; i++)
            C[i] = 0;
    for(j =1; j <= n; j++)
        C[A[j]] = C[A[j]] + 1;
    for(i = 1; i <= k; i++)
        C[i] = C[i] + C[i-1];
    for(j = n; j >= 1; j--)
    {
        B[C[A[j]]] = A[j];
        C[A[j]] = C[A[j]] - 1;
    }
    printf("\nThe Sorted array is :");
    for(i = 1; i <= n; i++)
      printf("\t%d",B[i]);
}

int main()
{
    int n,i,k = 0, A[15];
    clrscr();
    printf("\n=========== Example of Counting Sort =========\n\n");
    printf("Enter the number of input : ");
    scanf("%d",&n);
    printf("\n\nEnter the elements to be sorted :\n");
    for ( i = 1; i <= n; i++)
    {
     scanf("%d",&A[i]);
     if(A[i] > k)
     {
        k = A[i];
     }
    }
    Counting_sort(A, k, n);
    getch();
}

 ===============================================================  

 OUTPUT:

C EXAMPLE : RADIX SORT

SOURCE CODE :
===============================================================

#include<stdio.h>
#include<conio.h>

radix_sort(int array[], int n);
void main()
{
 int array[100],n,i;
 clrscr();
printf("\n\t========== Example of Redix Sort ===========\n\n");
printf("Enter the number of elements to be sorted: ");
 scanf("%d",&n);
 printf("\nEnter the elements to be sorted: \n");
 for(i = 0 ; i < n ; i++ )
 {
  printf("\tArray[%d] = ",i);
  scanf("%d",&array[i]);
 }

 printf("\nArray Before Radix Sort:");  //Array Before Radix Sort
 for(i = 0; i < n; i++)
 {
  printf("%8d", array[i]);
 }
 printf("\n");

 radix_sort(array,n);

 printf("\nArray After Radix Sort: ");  //Array After Radix Sort
 for(i = 0; i < n; i++)
 {
  printf("%8d", array[i]);
 }
 printf("\n");
 getch();
}

radix_sort(int arr[], int n)
{
 int bucket[10][5],buck[10],b[10];
 int i,j,k,l,num,div,large,passes;

 div=1;
 num=0;
 large=arr[0];

 for(i=0 ; i<n ; i++)
 {
  if(arr[i] > large)
   {
    large = arr[i];
   }
  
  while(large > 0)
  {
   num++;
   large = large/10;
  }
 
  for(passes=0 ; passes<num ; passes++)
  {
   for(k=0 ; k<10 ; k++)
   {
    buck[k] = 0;
   }
   for(i=0 ; i<n  ;i++)
   {
    l = ((arr[i]/div)%10);
    bucket[l][buck[l]++] = arr[i];
   }
  
   i=0;
   for(k=0 ; k<10 ; k++)
   {
    for(j=0 ; j<buck[k] ; j++)
    {
     arr[i++] = bucket[k][j];
    }
   }  
   div*=10;  
  }
 }
}

 ===============================================================  

 OUTPUT:

C EXAMPLE : HEAP SORT

SOURCE CODE :
===============================================================

#include<stdio.h>
#include<conio.h>

void heapsort(int[], int);
void heapify(int[], int);
void adjust(int[], int);

int main()
{
 int array[50],n,i;
 clrscr();
 printf("\n\n==========  Example of Heap Sort ==========\n\n");
 printf("Enter the no. of elements to be sorted: ");
 scanf("%d",&n);

 printf("\nEnter the elements: \n");
 for(i=0 ; i<n ; i++)
 scanf("%d",&array[i]);

 printf("\nBefore Heapsort:");  //Array Before Mergesort
 for(i = 0; i < n; i++)
 {
  printf("%4d", array[i]);
 }
 printf("\n");

 heapsort(array,n);

 printf("\nAfter Heapsort:");  //Array After Mergesort
 for(i = 0; i < n; i++)
 {
  printf("%4d", array[i]);
 }
 printf("\n");
 getch();
 return 0;
}

void heapsort(int array[], int n)
{
 int i,t;

 heapify(array,n);

 for(i=n-1 ; i>0 ; i--)
 {
  t = array[0];
  array[0] = array[i];
  array[i] = t;
  adjust(array,i);
 }
}


void heapify(int array[], int n)
{
 int item,i,j,k;

 for(k=1 ; k<n ; k++)
 {
  item = array[k];
  i = k;
  j = (i-1)/2;

  while( (i>0) && (item>array[j]) )
  {
   array[i] = array[j];
   i = j;
   j = (i-1)/2;
  }
  array[i] = item;
 }
}

void adjust(int array[], int n)
{
 int item,i,j;

 j = 0;
 item = array[j];
 i = 2*j+1;

  while(i<=n-1)
 {
  if(i+1 <= n-1)
   if(array[i] < array[i+1])
    i++;
  if(item < array[i])
  {
   array[j] = array[i];
   j = i;
   i = 2*j+1;
  }
  else
   break;
 }
 array[j] = item;
}

 ===============================================================  

 OUTPUT:

C EXAMPLE : QUICK SORT

SOURCE CODE :
===============================================================

#include<stdio.h>
#include<conio.h>

void quicksort(int [10],int,int);

int main(){
  int x[20],size,i;

  printf("Quick Sort Program in C\n\n");
  printf("Enter size of the array: ");
  scanf("%d",&size);

  printf("\nEnter %d values: ",size);
  for(i=0;i<size;i++)
    scanf("%d",&x[i]);

  quicksort(x,0,size-1);

  printf("\nSorted values: ");
  for(i=0;i<size;i++)
    printf(" %d",x[i]);

  getch();
  return 0;
}

void quicksort(int x[10],int first,int last){
    int pivot,j,temp,i;

     if(first<last){
         pivot=first;
         i=first;
         j=last;

         while(i<j){
             while(x[i]<=x[pivot]&&i<last)
                 i++;
             while(x[j]>x[pivot])
                 j--;
             if(i<j){
                 temp=x[i];
                  x[i]=x[j];
                  x[j]=temp;
             }
         }

         temp=x[pivot];
         x[pivot]=x[j];
         x[j]=temp;
         quicksort(x,first,j-1);
         quicksort(x,j+1,last);

    }
}

 ===============================================================  

 OUTPUT:

C EXAMPLE : MERGE SORT

SOURCE CODE :
===============================================================

#include<stdio.h>
#include<conio.h>
void merge(int [],int ,int ,int );
void part(int [],int ,int );
int main()
{
 int arr[30];
 int i,size;
 clrscr();
 printf("\n\t========== Example of Merge Sort ===========\n\n");
 printf("Enter total no. of elements : ");
 scanf("%d",&size);
 for(i=0; i<size; i++)
 {
   printf("Enter %d element : ",i+1);
   scanf("%d",&arr[i]);
 }
 part(arr,0,size-1);
 printf("\n\t==========  Sorted elements =============\n\n");
 for(i=0; i<size; i++)
 printf("%d ",arr[i]);
 getch();
 return 0;
getch();
}


void part(int arr[],int min,int max)
{
 int mid;
 if(min<max)
 {
   mid=(min+max)/2;
   part(arr,min,mid);
   part(arr,mid+1,max);
   merge(arr,min,mid,max);
 }
}


void merge(int arr[],int min,int mid,int max)
{
  int tmp[30];
  int i,j,k,m;
  j=min;
  m=mid+1;
  for(i=min; j<=mid && m<=max ; i++)
  {
     if(arr[j]<=arr[m])
     {
         tmp[i]=arr[j];
         j++;
     }
     else
     {
         tmp[i]=arr[m];
         m++;
     }
  }
  if(j>mid)
  {
     for(k=m; k<=max; k++)
     {
         tmp[i]=arr[k];
         i++;
     }
  }
  else
  {
     for(k=j; k<=mid; k++)
     {
        tmp[i]=arr[k];
        i++;
     }
  }
  for(k=min; k<=max; k++)
     arr[k]=tmp[k];
}

 ===============================================================  

 OUTPUT:

C EXAMPLE : SELECTION SORT

SOURCE CODE :
 ===============================================================

#include<stdio.h>
#include<conio.h>
main()
{
int s,i,j,temp,a[20];
clrscr();
  printf("\n========= Example of Selection Sort =======\n");
  printf("\nEnter total elements: ");
  scanf("%d",&s);
  printf("Enter %d elements:\n",s);
  for(i=0;i<s;i++)
      {
      scanf("%d",&a[i]);
      }
  for(i=0;i<s;i++)
     {
     for(j=i+1;j<s;j++)
    {
    if(a[i]>a[j])
      {
      temp=a[i];
      a[i]=a[j];
      a[j]=temp;
      }
    }
     }
  printf("\nAfter sorting the elements are: ");
  for(i=0;i<s;i++)
     {
      printf("\t%d",a[i]);
     }
getch();
}

 ===============================================================

OUTPUT:

C EXAMPLE : INSERTION SORT

SOURCE CODE :
===============================================================

#include<stdio.h>

#include<conio.h>

main()

{

  int n, array[1000], c, d, t;

  clrscr();

  printf("\n========== Example of Insertion Sort ===========\n\n");

  printf("Enter number of elements\n");

  scanf("%d", &n);

  printf("Enter %d integers\n", n);

  for (c = 0; c < n; c++)

      {

      scanf("%d", &array[c]);

      }

  for (c = 1 ; c <= n - 1; c++)

      {

      d = c;

      while ( d > 0 && array[d] < array[d-1]) {

      t          = array[d];

      array[d]   = array[d-1];

      array[d-1] = t;

      d--;

    }

  }

  printf("Sorted list in ascending order:\n");

  for (c = 0; c <= n - 1; c++) {

    printf("%d\n", array[c]);

  }

 getch();

}

 ===============================================================  

 OUTPUT: