Sorting algorithms

Macros
#define	BEAD(i, j)   beads[i * max + j]
	Create easy access of elements from a 2D matrix stored in memory as a 1D array.

Functions
void	display (const int *arr, int n)
	Displays the array, passed to this method.
void	bead_sort (int *a, size_t len)
	This is where the sorting of the array takes place.
void	RecursionInsertionSort (int *arr, int size)
	Insertion sort algorithm implements using Recursion.
void	swap (int *a, int *b)
	Swap two integer variables.
void	merge (int *a, int l, int r, int n)
	Perform merge of segments.
void	merge_sort (int *a, int n, int l, int r)
	Merge sort algorithm implementation.
void	show_data (int *arr, long len)
	Helper function to print array values.
void	shell_sort (int *array, long LEN)
	Shell sort algorithm.

Detailed Description

Function Documentation

bead_sort()

void bead_sort	(	int *	a,
		size_t	len
	)

This is where the sorting of the array takes place.

Parameters

[in,out]	a	array to be sorted
[in]	len	Array Size

{
    int i, j, max, sum;
    unsigned char *beads;
 
    for (i = 1, max = a[0]; i < len; i++)
        if (a[i] > max)
            max = a[i];
 
    beads = calloc(1, max * len);
 
    /* mark the beads */
    for (i = 0; i < len; i++)
        for (j = 0; j < a[i]; j++) BEAD(i, j) = 1;
 
    for (j = 0; j < max; j++)
    {
        /* count how many beads are on each post */
        for (sum = i = 0; i < len; i++)
        {
            sum += BEAD(i, j);
            BEAD(i, j) = 0;
        }
        /* mark bottom sum beads */
        for (i = len - sum; i < len; i++) BEAD(i, j) = 1;
    }
 
    for (i = 0; i < len; i++)
    {
        for (j = 0; j < max && BEAD(i, j); j++)
            ;
        a[i] = j;
    }
    free(beads);
}

display()

void display	(	const int *	arr,
		int	n
	)

Displays the array, passed to this method.

Parameters

[in]	arr	array to display
[in]	n	number of elements in the array

{
    for (int i = 0; i < n; i++)
    {
        printf("%d ", arr[i]);
    }
 
    printf("\n");
}

merge()

void merge	(	int *	a,
		int	l,
		int	r,
		int	n
	)

Perform merge of segments.

Parameters

a	array to sort
l	left index for merge
r	right index for merge
n	total number of elements in the array

{
    int *b = (int *)malloc(n * sizeof(int)); /* dynamic memory must be freed */
    if (b == NULL)
    {
        printf("Can't Malloc! Please try again.");
        exit(EXIT_FAILURE);
    }
    int c = l;
    int p1, p2;
    p1 = l;
    p2 = ((l + r) / 2) + 1;
    while ((p1 < ((l + r) / 2) + 1) && (p2 < r + 1))
    {
        if (a[p1] <= a[p2])
        {
            b[c++] = a[p1];
            p1++;
        }
        else
        {
            b[c++] = a[p2];
            p2++;
        }
    }
 
    if (p2 == r + 1)
    {
        while ((p1 < ((l + r) / 2) + 1))
        {
            b[c++] = a[p1];
            p1++;
        }
    }
    else
    {
        while ((p2 < r + 1))
        {
            b[c++] = a[p2];
            p2++;
        }
    }
 
    for (c = l; c < r + 1; c++) a[c] = b[c];
 
    free(b);
}

merge_sort()

void merge_sort	(	int *	a,
		int	n,
		int	l,
		int	r
	)

Merge sort algorithm implementation.

Parameters

a	array to sort
n	number of elements in the array
l	index to sort from
r	index to sort till

{
    if (r - l == 1)
    {
        if (a[l] > a[r])
            swap(&a[l], &a[r]);
    }
    else if (l != r)
    {
        merge_sort(a, n, l, (l + r) / 2);
        merge_sort(a, n, ((l + r) / 2) + 1, r);
        merge(a, l, r, n);
    }
 
    /* no change if l == r */
}

Here is the call graph for this function:

RecursionInsertionSort()

void RecursionInsertionSort	(	int *	arr,
		int	size
	)

Insertion sort algorithm implements using Recursion.

Parameters

arr	array to be sorted
size	size of array

{
    if(size <= 0)
    {
        return;
    }
    
    // marking recursive call to reach starting element
    RecursionInsertionSort(arr,size-1);
    
    int key = arr[size-1];
    int j = size-2;
    // swapping logic for insertion sort
    while(j >= 0 && arr[j] > key)
    {
        arr[j+1] = arr[j];
        j--;
    }
    arr[j+1] = key;
}

Here is the call graph for this function:

shell_sort()

void shell_sort	(	int *	array,
		long	LEN
	)

Shell sort algorithm.

Optimized algorithm - takes half the time as other

Parameters

[in,out]	array	array to sort
[in]	LEN	length of the array

{
    const int gaps[] = {701, 301, 132, 57, 23, 10, 4, 1};
    const int gap_len = 8;
    long i, j, g;
 
    for (g = 0; g < gap_len; g++)
    {  // for each gap
        int gap = gaps[g];
        for (i = gap; i < LEN; i++)
        {  // from gap position to the end
            int tmp = array[i];
 
            for (j = i; j >= gap && (array[j - gap] - tmp) > 0; j -= gap)
                array[j] = array[j - gap];
            array[j] = tmp;
        }
    }
#ifdef DEBUG
    for (i = 0; i < LEN; i++) printf("%s\t", data[i]);
#endif
}

show_data()

void show_data	(	int *	arr,
		long	len
	)

Helper function to print array values.

{
    for (long i = 0; i < len; i++) printf("%3d ", arr[i]);
    printf("\n");
}

swap()

void swap ( int *  a, int *  b  )

inline

Swap two integer variables.

Function to swap values of two integers.

Parameters

[in,out]	a	pointer to first variable
[in,out]	b	pointer to second variable
[in,out]	a	reference to first variable
[in,out]	b	reference to second variable

{
    int t;
    t = *a;
    *a = *b;
    *b = t;
}