排序算法要点及其C语言实现

1. 快速排序：

不稳定排序，原址排序

最好情况复杂度：O(nlgn)

最坏情况复杂度：O(n^2)，当输入数组已经排好序时（包括所有元素都一样时）。

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

void PrintArrays(const int* a, const int num_elements)
{
	for (int i = 0; i < num_elements; ++i)
	{
		printf("%d\t", a[i]);
	}
	printf("\n");
}

void Swap(int* a, int* b)
{
	const int temp = *a;
	*a = *b;
	*b = temp;
}

int RandomInRange(const int min, const int max)
{
	srand(time(NULL));
	const int index = rand() % (max - min + 1) + min;
	return index;
}

int Partition(int* a, const int length, const int first, const int last)
{
	if (a == NULL || length <= 0 || first < 0 || last >= length)
	{
		fprintf(stderr, "Invalid Parameters");
		exit(EXIT_FAILURE);
	}

	const int index = RandomInRange(first, last);
	Swap(&a[index], &a[last]);

	int i = first - 1;
	for (int j = first; j < last; ++j)
	{
		if (a[j] <= a[last])
		{
			++i;
			if (i != j)
				Swap(&a[i], &a[j]);
		}
	}

	++i;
	Swap(&a[i], &a[last]);

	return i;
}

void QuickSort(int* a, const int length, const int first, const int last)
{
	if (first < last)
	{
		const int index = Partition(a, length, first, last);
		QuickSort(a, length, first, index - 1);
		QuickSort(a, length, index + 1, last);
	}
}

int main(int argc, char** argv)
{
	int a[8] = { 11, 10, 13, 5, 8, 3, 2, 8 };
	printf("Before Sorting: \n");
	PrintArrays(a, 8);

	QuickSort(a, 8, 0, 7);

	printf("After Sorting : \n");
	PrintArrays(a, 8);

	return 0;
}

2.归并排序：

稳定排序，非原址排序

最好情况复杂度：O(nlgn)

最坏情况复杂度：O(nlgn)

缺点：需要额外内存空间O(n)

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

void PrintArrays(const int* a, const int num_elements)
{
	for (int i = 0; i < num_elements; ++i)
	{
		printf("%d\t", a[i]);
	}
	printf("\n");
}

void Merge(int* a, int* aux, const int first, const int middle, const int last)
{
	if (a == NULL || aux == NULL)
	{
		fprintf(stderr, "Invalid Parameters!\n");
		exit(EXIT_FAILURE);
	}

	const int n1 = middle - first + 1;
	const int n2 = last - middle;

	for (int i = 0; i < n1; ++i)	//将子数组a[first...middle]拷贝到辅助数组aux前半部分		
	{
		aux[i] = a[first + i];
	}

	for (int j = 0; j < n2; ++j)	//将子数组a[middle+1...last]拷贝到辅助数组aux后半部分 				
	{
		aux[n1 + 1 + j] = a[middle + 1 + j];
	}

	aux[n1] = INT_MAX;				// 保存哨兵值
	aux[n1 + n2 + 1] = INT_MAX;		// 保存哨兵值

	int i = 0;
	int j = n1 + 1;
	int k;
	for (k = first; k < last; ++k)			//将数组元素值两两比较，并合并到原数组a  
	{
		if (aux[i] <= aux[j])
			a[k] = aux[i++];
		else
			a[k] = aux[j++];
	}

	for (; i < n1; ++i)
		a[k++] = aux[i];

	for (; j < n2; ++j)				
		a[k++] = aux[j];
}

void MergeSort(int* a, int* aux, const int first, const int last)
{
	if (first < last)							
	{
		const int middle = (first + last) / 2;	        
		MergeSort(a, aux, first, middle);				
		MergeSort(a, aux, middle + 1, last);          
		Merge(a, aux, first, middle, last);				
	}
}

int main(int argc, char** argv)
{
	const int num_elements = 8;
	int a[num_elements] = { 11, 10, 13, 5, 8, 3, 2, 8 };
	//int a[num_elements] = { 1, 5, 2, 4, 6, 3, 2, 6 };
	int aux[num_elements + 2];				//多余的两个元素存放哨兵值INT_MAX
	printf("Before Sorting: \n");
	PrintArrays(a, 8);

	MergeSort(a, aux, 0, 7);

	printf("After Sorting : \n");
	PrintArrays(a, 8);

	return 0;
}

3. 插入排序：

    稳定排序，原址排序

最好情况复杂度：O(n)，当输入数组已经排好序时。

最坏情况复杂度：O(n^2)，当输入数组为逆序时。

平均时间复杂度：O(n^2)

适合用于排序“元素数目较少的数组”。

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

void PrintArrays(const int* a, const int num_elements)
{
	for (int i = 0; i < num_elements; ++i)
	{
		printf("%d\t", a[i]);
	}
	printf("\n");
}

void InsertionSort(int* a, const int length)
{
	if (a == NULL || length <= 0)
	{
		fprintf(stderr, "Invalid Parameters!\n");
		exit(EXIT_FAILURE);
	}

	for (int j = 1; j < length; ++j)
	{
		const int key = a[j];
		int i = j - 1;
		while (i >= 0 && a[i] > key)
		{
			a[i + 1] = a[i];
			--i;  
		}

		a[i + 1] = key;
	}
}

int main(int argc, char** argv)
{
	int a[8] = { 11, 10, 13, 5, 8, 3, 2, 8 };
	printf("Before Sorting: \n");
	PrintArrays(a, 8);

	InsertionSort(a, 8);

	printf("After Sorting : \n");
	PrintArrays(a, 8);

	return 0;
}

4. 计数排序：

稳定排序，非原址排序。

最好情况复杂度：O(n+k)

最坏情况复杂度：O(n+k)

缺点：需要额外内存空间O(n+k)

基本思想：对每个输入的整数元素x（范围为：0-k），确定小于x的元素个数m。根据这一信息，可以直接把x放在输出数组的位置m+1上了。

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

void PrintArrays(const int* a, const int num_elements)
{
	for (int i = 0; i < num_elements; ++i)
	{
		printf("%d\t", a[i]);
	}
	printf("\n");
}

void CountingSort(const int* a, int* output, const int length, const int k, const int first, const int last)
{
	if (a == NULL || length <= 0)
	{
		fprintf(stderr, "Invalid Parameters!\n");
		exit(EXIT_FAILURE);
	}

	int* counter = (int*)malloc((k+1)*sizeof(int));

	for (int i = 0; i <= k; ++i)
		counter[i] = 0;

	for (int j = 0; j < length; ++j)
		++counter[a[j]];

	// 现在counter[i]存储值等于i的元素个数
	for (int i = 1; i <= k; ++i)
		counter[i] += counter[i - 1];

	// 现在counter[i]存储值小于等于i的元素个数
	for (int j = length - 1; j >= 0; --j)
	{
		output[counter[a[j]] - 1] = a[j];
		--counter[a[j]];	
	}

	free(counter);
}

int main(int argc, char** argv)
{
	const int kMaxValue = 100;
	const int a[8] = { 11, 10, 13, 5, 8, 3, 2, 8 };
	int output_a[8];
	printf("Before Sorting: \n");
	PrintArrays(a, 8);

	CountingSort(a, output_a, 8, kMaxValue, 0, 7);

	printf("After Sorting : \n");
	PrintArrays(output_a, 8);

	return 0;
}

5. 基数排序：

稳定排序，非原址排序。

最好情况复杂度：O((n+k)d)

最坏情况复杂度：O((n+k)d)

基本思想: 将待比较整数的位数长度统一，数位较短的数值前面补零。从最低有效位开始逐位进行一次稳定排序，完成所有位数的排序后，该数列便成为一个有序序列。

6. 希尔排序：

希尔排序的运行时间依赖于增量序列的选取。

最优时间复杂度：O( n*log(2n) )
平均时间复杂度：希尔增量O(n^2)，Hibbard增量O(n^3/2)
稳定性：不稳定

注：希尔排序算法是直接插入排序算法的一种改进。步长的选择很重要。只要最终步长为1的选择都可以工作，最后一步为步长为1的希尔排序-插入排序。

适用场景：中等大小规模，性能要求不高的场合。

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

void PrintArrays(const int* a, const int num_elements)
{
	for (int i = 0; i < num_elements; ++i)
	{
		printf("%d\t", a[i]);
	}
	printf("\n");
}

void ShellSort(int* array, const int len)
{
	if (array == NULL || len <= 0)
		return;

	for (int gap = (len >> 1); gap > 0; gap >>= 1)
	{
		for (int i = gap; i < len; ++i)
		{
			for (int j = i - gap; j >= 0 && array[j] > array[j + gap]; j -= gap)
			{
				int temp = array[j];
				array[j] = array[j + gap];
				array[j + gap] = temp;
			}
		}
	}
}

int main(int argc, char** argv)
{
	int a[8] = { 11, 10, 13, 5, 8, 3, 2, 8 };
	printf("Before Sorting: \n");
	PrintArrays(a, 8);

	ShellSort(a, 8);

	printf("After Sorting : \n");
	PrintArrays(a, 8);

	return 0;
}