Program of Selection Sort

#include <stdio.h>

int main()

{

   int array[100], n, c, d, position, swap;

   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 = 0 ; c < ( n - 1 ) ; c++ )

   {

      position = c;

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

      {

         if ( array[position] > array[d] )

            position = d;

      }

      if ( position != c )

      {

         swap = array[c];

         array[c] = array[position];

         array[position] = swap;

      }

   }

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

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

{

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

      return 0;

}

Program of RadixSort

void radixSort(vector<int>& a, int base)
{
  int const MAX = 10;
  static vector<int> buckets[MAX];
  int pow = 1;
 
  for (int i = 0; i < MAX; ++i)
  {
    buckets[i].resize(a.size());
    buckets[i][0] = 0;
  }

  for (int i = 0; i < base; ++i, pow *= 10)
  {
    for (int j = 0; j < MAX; ++j)
    {
      buckets[j][0] = 0;
    }

    for (int j = 0; j < a.size(); ++j)
    {
      int index = (a[j] / pow) % 10;
      buckets[index][++buckets[index][0]] = a[j];
    }
     
    int cnt = 0;
    for (int j = 0; j < MAX; ++j)
    {
      for (int k = 0; k < buckets[j][0]; ++k)
      {
        a[cnt++] = buckets[j][k + 1];
      }
    }
  }
}

void RadixSort(int A[], int size)
{
    int d = 1;
        for(int i = 0; i < size; ++i)
        {
            int digits_temp;
            digits_temp=(int)log10(abs(A[i]!=0 ? abs(A[i]) : 1)) +1;
            if(digits_temp > d)
                d = digits_temp;
        }
        d += 1;

*rest of the implementation*
{

program of Quick Sort

#include<stdio.h>

#include<conio.h>

void qsort(int, int, int) ;     //Prototype

int main( )

{

    int arr[30];

    int i, size ;

    printf("Enter total number of Elements:  ") ;

    scanf("%d", &size);

    printf("Enter the Elements: \n")

    for(i=0; i<size; i++)

       scanf("%d", &arr[i]) ;

    qsort(arr, 0, size-1) ;    //calling

    printf("Quick Sorted elements are as:  \n") ;

    for(i=0; i<size; i++)

       printf("%d\t",arr[i]);

    return 0;

}

void qsort(int arr[20], int frst, int last)     //definition

 {

   int i, j, pivot, tmp;

     if(frst<last)

        {

            pivot=frst ;

            i=frst ;

            j=last;

           while(i<j)

             {

                while(arr[i]<=arr[pivot] && i<last)

                      i++  ;

                while(arr[j]>arr[pivot])

                      j-- ;

                if(i<j)

                   {

                         tmp=arr[i];

                         arr[i]=arr[j] ;

                         arr[j]=tmp;

                    }

             }                     //end of while loop

        tmp=arr[pivot] ;

        arr[pivot]= arr[j];

        arr[j]=tmp ;

        qsort(arr,frst,j=1) ;

        qsort(arr, j+1, last) ;

     }                    //end of if statement

}

Program of MergeSort

void mergeSort(int numbers[], int temp[], int array_size)

{
        m_sort(numbers, temp, 0, array_size - 1);
}
void m_sort(int numbers[], int temp[], int left, int right)
{
        int mid;

        if (right > left)
    {

            mid = (right + left) / 2;

            m_sort(numbers, temp, left, mid);

            m_sort(numbers, temp, mid+1, right);


            merge(numbers, temp, left, mid+1, right);

        }

}



void merge(int numbers[], int temp[], int left, int mid, int right)

        {

            int i, left_end, num_elements, tmp_pos;


            left_end = mid - 1;

            tmp_pos = left;

            num_elements = right - left + 1;



while ((left <= left_end) && (mid <= right))

        {

                if (numbers[left] <= numbers[mid])

                {

                        temp[tmp_pos] = numbers[left];

                        tmp_pos = tmp_pos + 1;

                        left = left +1;

                }

                else

                {

                        temp[tmp_pos] = numbers[mid];

                        tmp_pos = tmp_pos + 1;

                        mid = mid + 1;

                }

        }



        while (left <= left_end)

                {

                        temp[tmp_pos] = numbers[left];

                        left = left + 1;

                        tmp_pos = tmp_pos + 1;

                }

                while (mid <= right)

                {

                        temp[tmp_pos] = numbers[mid];

                        mid = mid + 1;

                        tmp_pos = tmp_pos + 1;

                }



                for (i = 0; i <= num_elements; i++)

                {

                        numbers[right] = temp[right];

                        right = right - 1;

                }

        }

Program of Cycle Sort

  #include <stdio.h>

  #define MAX 8

   

      void cycle_sort(int *);

      void main()

{

    int a[MAX],i; 

    printf("enter the elements into array :");

    for (i = 0;i < MAX; i++)

    {

        scanf("%d", &a[i]);

    }

    cycle_sort(a);

    printf("sorted elements are :\n");

    for (i = 0;i < MAX; i++)

    {

        printf("%d", a[i]);

    }

}

   /* sorts elements using cycle sort algorithm */

 void cycle_sort(int * a)

{

    int temp, item, pos, i, j, k;

    for (i = 0;i < MAX; i++)

    {

        item = a[i];

        pos = i;

        do

        {

            k = 0;

            for (j = 0;j < MAX;j++)

            {

                if (pos != j && a[j] < item)

                {

                    k++;

                }

            }

            if (pos != k)

            {

                while (pos != k && item == a[k])

                {

                    k++;

                }

                temp = a[k];

                a[k] = item;

                item = temp;

                pos = k;

            }

        }while (pos != i);

    }

}

Program of Bucket Sort

void Bucket_Sort(int array[], int n)

{  

 int i, j;  

 int count[n]; 

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

 {  

  count[i] = 0;  

 }    

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

 {   

  (count[array[i]])++;

 }    

 for(i=0,j=0; i < n; i++)

 {  

  for(; count[i]>0;(count[i])--)

  {      

   array[j++] = i;

  } 

 }  

}   

int main()

{

 int array[100];  

 int num;  

 int i; 

 printf("Enter How many Numbers : ");   

 scanf("%d",&num);   

 printf("Enter the %d elements to be sorted:\n",num); 

 for(i = 0; i < num; i++ )

 {  

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

 }  

 printf("\nThe array of elements before sorting : \n");

 for (i = 0;i < num;i++)

 {   

  printf("%d ", array[i]);  

 }   

 printf("\nThe array of elements after sorting : \n"); 

 Bucket_Sort(array, num); 

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

 {    

  printf("%d ", array[i]); 

 }  

 printf("\n");     

 return 0;

} 

Program of Bubble Sort

void bubbleSort(int arr[]){

int i;

int j;

int temp;

for(i = arr.length-1; i > 0; i--){

for(j = 0; j < i; j++){

if(arr[j] > arr[j+1]){

temp = arr[j];

arr[j] = arr[j+1];

arr[j+1] = temp;

}//

}// end inner loop

}//end outer loop}// end bubble sort