WAP to implement Quick Sort.

//WAP to implement Quick Sort.

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

void swap (int a[], int left, int right) // function for swapping
      {
        int temp;
        temp=a[left];
        a[left]=a[right];
        a[right]=temp;
      }

// Sorting logic
void quicksort( int a[], int low, int high ) // function for performing quick sort

      {
        int pivot;
                       
        if ( high > low )// Termination condition! 
         {
           pivot = partition( a, low, high );
           quicksort( a, low, pivot-1 );
           quicksort( a, pivot+1, high );
         }

      } //end Quick sort

int partition( int a[], int low, int high ) // Partition function
      {
        int left, right, pivot_item, pivot = left = low;
        pivot_item = a[low];
        right = high;

           while ( left < right )
            {
                 while( a[left] <= pivot_item ) // Move left while item < pivot 

                 left++;
                 while( a[right] > pivot_item ) // Move right while item > pivot 

                 right--;
                 if ( left < right )
                  swap(a,left,right);
            }
                                                           

        a[low] = a[right];  // right is final position for the pivot
        a[right] = pivot_item;
        return right;

      }//end partition

void printarray(int a[], int); // void quicksort(int a[], int, int);

int main()
      {
        int a[50], i, n;

        printf("\nEnter no. of elements: ");
        scanf("%d", &n); //inputting array size

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

        quicksort(a,0,n-1);

        printf("\nSorted elements: \n");
        printarray(a,n); // printing sorted array

        getch(); // for holding the console screen

      } // end main

void printarray(int a[], int n) // function for printing array
      {
        int i;
        for (i=0; i<n; i++)
          printf(" %d ", a[i]);
          printf("\n");
       } // end printarray

WAP to implement Merge Sort.

//WAP to implement Merge Sort.

#include <stdio.h>
#include <stdlib.h>

#include<conio.h>

#define MAX_ARY 10

void merge_sort(int x[], int end, int start);

clrscr();

int main(void) 

      {
        int ary[MAX_ARY];
        int j = 0;

        printf("\n\nEnter the elements to be sorted: \n");
        for(j=0;j<MAX_ARY;j++)
        scanf("%d",&ary[j]);/* array before mergesort */

        printf("Before :");
              for(j = 0; j < MAX_ARY; j++)
                printf(" %d", ary[j]);
                printf("\n");

        merge_sort(ary, 0, MAX_ARY - 1);
        printf("After Merge Sort :");/* array after mergesort */
              for(j = 0; j < MAX_ARY; j++)
                printf(" %d", ary[j]);
                printf("\n");
       getch();

      }

/* Method to implement Merge Sort*/void merge_sort(int x[], int end, int start) 

      {
        int j = 0;
        const int size = start - end + 1;
        int mid = 0, mrg1 = 0, mrg2 = 0, executing[MAX_ARY];
              if(end == start)
         return;
             mid = (end + start) / 2;

merge_sort(x, end, mid);
merge_sort(x, mid + 1, start);

      for(j = 0; j < size; j++)
        executing[j] = x[end + j];
        mrg1 = 0;
        mrg2 = mid - end + 1;
              for(j = 0; j < size; j++) 

               {
                 if(mrg2 <= start - end)
                   if(mrg1 <= mid - end)
                     if(executing[mrg1] > executing[mrg2])
                       x[j + end] = executing[mrg2++];
                        else
                          x[j + end] = executing[mrg1++];
                           else
                            x[j + end] = executing[mrg2++];
                             else
                              x[j + end] = executing[mrg1++];
                 }
      }