SHELL SORT - DSTC using C Language (Source Code Implemented)

SHELL SORT
Implemented using C Language 

C Language Code: 

---

 SHELL.C

---

// SHELL SORTING using C Language

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

#define NUM_ITEMS 10

void shellSort(int numbers[], int array_size);
void prnArray(int numbers[], int array_size) ;

int numbers[NUM_ITEMS];

int main()
{
    int i;
    clrscr() ;
    //seed random number generator
    srand(getpid());

    //fill array with random integers
    for (i = 0; i < NUM_ITEMS; i++)
        numbers[i] = rand();

    printf("\n Before SHELL Sort.\n");
    prnArray(numbers, NUM_ITEMS) ;

    //perform shell sort on array
    shellSort(numbers, NUM_ITEMS);

    printf("\n After SHELL Sort.\n");
    prnArray(numbers, NUM_ITEMS) ;

}

void shellSort(int numbers[], int array_size)
{
    int i, j, increment, temp;

    increment = 3;
    while (increment > 0)
    {
        for (i=0; i < array_size; i++)
        {
            j = i;
            temp = numbers[i];

        while ((j >= increment) && (numbers[j-increment] > temp))
            {
                numbers[j] = numbers[j - increment];
                j = j - increment;
            }
            numbers[j] = temp;
        }
if (increment/2 != 0)
            increment = increment/2;
        else if (increment == 1)
            increment = 0;
        else
            increment = 1;
    }
}

void prnArray(int numbers[], int array_size)
{
    int x ;
    for(x=0; x < array_size; x++)
        printf("%d\t", numbers[x]) ;
}

SELECTION SORT - DSTC using C Language (Source Code Implemented)

SELECTION SORT
Implemented using C Language

C Language Code:

---

SELECTION.C

---

// SELECTION SORTING using C Language

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

#define NUM_ITEMS 10

void selectionSort(int numbers[], int array_size);
void prnArray(int numbers[], int array_size) ;

int numbers[NUM_ITEMS];

int main()
{
    int i;
    clrscr() ;
    //seed random number generator
    srand(getpid());

    //fill array with random integers
    for (i = 0; i < NUM_ITEMS; i++)
       numbers[i] = rand();

   printf("\n Before SELECTION Sort.\n");
    prnArray(numbers, NUM_ITEMS) ;

    //perform selection sort on array
    selectionSort(numbers, NUM_ITEMS);

    printf("\n After SELECTION Sort.\n");
    prnArray(numbers, NUM_ITEMS) ;
}

void selectionSort(int numbers[], int array_size)
{
    int i, j;
    int min, temp;

    for (i = 0; i < array_size-1; i++)
    {
        min = i;

        for (j = i+1; j < array_size; j++)
        {
            if (numbers[j] < numbers[min])
                min = j;
        }
        temp = numbers[i];
        numbers[i] = numbers[min];
        numbers[min] = temp;
    }
} 

 void prnArray(int numbers[], int array_size)
{
    int x ;
    for(x=0; x < array_size; x++)
        printf("%d\t", numbers[x]) ;
}

QUICK SORT - DSTC using C Language (Source Code Implemented)

QUICK SORT
Implemented using C Language  

C Language Code: 

---

QUICK.C

---

// QUICK SORTING using C Language

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

#define NUM_ITEMS 10

void quickSort(int numbers[], int array_size);
void q_sort(int numbers[], int left, int right);
void prnArray(int numbers[], int array_size) ;

int numbers[NUM_ITEMS];

int main()
{
    int i;
    clrscr() ;
    //seed random number generator
    srand(getpid());

    //fill array with random integers
    for (i = 0; i < NUM_ITEMS; i++)
        numbers[i] = rand();

    printf("\n Before Quick Sort.\n");
    prnArray(numbers, NUM_ITEMS) ;

    //perform quick sort on array
    quickSort(numbers, NUM_ITEMS);

    printf("\n After Quick Sort.\n") ;
    prnArray(numbers, NUM_ITEMS) ;
}

void quickSort(int numbers[], int array_size)
{
    q_sort(numbers, 0, array_size - 1) ;
}

void q_sort(int numbers[], int left, int right)
{
    int pivot, l_hold, r_hold;

    l_hold = left;
    r_hold = right;
    pivot = numbers[left];
    while (left < right)
    {
        while ((numbers[right] >= pivot) && (left < right))
            right--;
        if (left != right)
        {
            numbers[left] = numbers[right];
            left++;
        }

        while ((numbers[left] <= pivot) && (left < right))
            left++;
        if (left != right)
        {
            numbers[right] = numbers[left];
            right--;
        }

}
    numbers[left] = pivot;
    pivot = left;
    left = l_hold;
    right = r_hold;
    if (left < pivot)
        q_sort(numbers, left, pivot-1);
    if (right > pivot)
        q_sort(numbers, pivot+1, right);
}

void prnArray(int numbers[], int array_size)
{
    int x ;
    for(x=0; x < array_size; x++)
        printf("%d\t", numbers[x]) ;
}

 

MERGE SORT - DSTC using C Language (Source Code Implemented)

MERGE SORT
Implemented using C Language

// MERGE SORT in C Language

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

#define NUM_ITEMS 10

void mergeSort(int numbers[], int temp[], int array_size);
void m_sort(int numbers[], int temp[], int left, int right);
void merge(int numbers[], int temp[], int left, int mid, int right);
void prnArray(int numbers[], int array_size) ;

int numbers[NUM_ITEMS];
int temp[NUM_ITEMS];

int main()
{
    int i;
    clrscr();

    //seed random number generator
    srand(getpid());

    //fill array with random integers
    for (i = 0; i < NUM_ITEMS; i++)
        numbers[i] = rand();

    printf("\nBefore MERGE Sort.\n");
    prnArray(numbers, NUM_ITEMS) ;
    //perform merge sort on array
    mergeSort(numbers, temp, NUM_ITEMS);

    printf("\nAfter MERGE Sort.\n");
    prnArray(numbers, NUM_ITEMS) ;
}

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;
    }
}

void prnArray(int numbers[], int array_size)
{
    int x ;
    for(x=0; x < array_size; x++)
        printf("%d\t", numbers[x]) ;
}

 C Language Code:

---

MERGE.C

INSERTION SORT - DSTC using C Language (Source Code Implemented)

INSERTION SORT
Implemented using C Language

C Language Code:  

---

INSERTION.C

---

// INSERTION SORTING using C Language

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

#define NUM_ITEMS 5

void insertionSort(int numbers[], int array_size);
void prnArray(int numbers[], int array_size) ;

int numbers[NUM_ITEMS];

int main()
{
    int i;
    clrscr() ;
    //seed random number generator
    srand(getpid());

//fill array with random integers
    for (i = 0; i < NUM_ITEMS; i++)
        numbers[i] = rand();

   printf("\nBefore Insertion Sort\n");
    prnArray(numbers, NUM_ITEMS) ;

    //perform insertion sort on array
    insertionSort(numbers, NUM_ITEMS);

printf("\nAfter Insertion Sort\n");
    prnArray(numbers, NUM_ITEMS) ;

}

void insertionSort(int numbers[], int array_size)
{
    int i, j, index ;

    for (i=1; i < array_size; i++)
    {
        index = numbers[i];
        j = i;

        while ((j > 0) && (numbers[j-1] > index))
        {
            numbers[j] = numbers[j-1];
            j = j - 1;
        }
        numbers[j] = index ;
    }
}

void prnArray(int numbers[], int array_size)
{
    int x ;
    for(x=0; x < array_size; x++)
        printf("%d\t", numbers[x]) ;
}

HEAP SORT - DSTC using C Language (Source Code Implemented)

HEAP SORT
Implemented using C Language

C Language Code:  

---

HEAP.C

---

 // HEAP SORTING using C Language

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

#define NUM_ITEMS 8

void heapSort(int numbers[], int array_size);
void siftDown(int numbers[], int root, int bottom);
void prnArray(int numbers[], int array_size) ;

int numbers[NUM_ITEMS];

int main()
{
    int i;
    clrscr() ;
    //seed random number generator
    srand(getpid());

    //fill array with random integers
    for (i = 0; i < NUM_ITEMS; i++)
        numbers[i] = rand();

    printf("\nBefore Heap sort.\n");
    prnArray(numbers, NUM_ITEMS) ;

    //perform heap sort on array
    heapSort(numbers, NUM_ITEMS);

    printf("\nAfter Heap sort\n");
    prnArray(numbers, NUM_ITEMS) ;

}

void heapSort(int numbers[], int array_size)
{
    int i, temp;

    for (i = (array_size / 2)-1; i >= 0; i--)
        siftDown(numbers, i, array_size);

    for (i = array_size-1; i >= 1; i--)
    {

        temp = numbers[0];
        numbers[0] = numbers[i];
        numbers[i] = temp;
        siftDown(numbers, 0, i-1);
    }
}

void siftDown(int numbers[], int root, int bottom)
{
    int done, maxChild, temp;

    done = 0;
    while ((root*2 <= bottom) && (!done))
    {
        if (root*2 == bottom)
            maxChild = root * 2;
        else if (numbers[root * 2] > numbers[root * 2 + 1])
            maxChild = root * 2;
        else
            maxChild = root * 2 + 1;

        if (numbers[root] < numbers[maxChild])
        {
            temp = numbers[root];
            numbers[root] = numbers[maxChild];
            numbers[maxChild] = temp;
            root = maxChild;
        }
        else
            done = 1;
    }
}

void prnArray(int numbers[], int array_size)
{
    int x ;
    for(x=0; x < array_size; x++)
        printf("%d\t", numbers[x]) ;
}