计数排序以及排序总结

技数排序

计数排序又称为鸽巢原理，是对哈希直接定址法的变形应用。
思路：

1. 统计相同元素出现次数
2. 根据统计的结果将序列回收到原来的序列中
   

void CountSort(int* arr, int n)
{
	//寻找最大、最小值
	int max=arr[0], min = arr[0];
	for (int i = 0; i < n; i++)
	{
		if (arr[i] < min)
		{
			min = arr[i];
		}
		if (arr[i] > max)
		{
			max = arr[i];
		}
	}
	//通过最大、最小值来确定数组开辟空间大小
	int range = max - min + 1;
	int* tmp = (int*)malloc(sizeof(int) * range);
	if (tmp == NULL)
	{
		perror("malloc fail!");
		exit(1);
	}
	//初始化
	memset(tmp, 0, sizeof(int) * range);
	//计数
	for (int i = 0; i < n; i++)
	{
		tmp[arr[i] - min]++;
	}
	//排序
	int j = 0;
	for (int i = 0; i < range; i++)
	{
		while (tmp[i]--)
		{
			arr[j++] = i+min;
		}
	}
}

计数排序的特性：

• 计数排序在数据范围集中时，效率很高，但是适用范围及场景有限。
• 时间复杂度：O(N+range)
• 空间复杂度：O(range)

排序算法复杂度及稳定性总结

稳定性：假定在待排序的记录序列中，存在多个具有相同的关键字的记录，若经过排序，这些记录的相对次序保持不变，即在原序列中，r[i]=r[j]，且r[i]在r[j]之前，而在排序后的序列中，r[i]仍在r[j]之前，则称这种排序算法是稳定的；否则称为不稳定的。

排序方式	平均情况	最好情况	最坏情况	辅助空间	稳定性
冒泡排序	O(n^2)	O(n)	O(n^2)	O(1)	稳定
直接选择排序	O(n^2)	O(n^2)	O(n^2)	O(1)	不稳定
直接插入排序	O(n^2)	O(n)	O(n^2)	O(1)	稳定
希尔排序	O(nlogn)-O(n^2)	O(n^1.3)	O(n^2)	O(1)	不稳定
堆排序	O(nlogn)	O(nlogn)	O(nlogn)	O(1)	不稳定
归并排序	O(nlogn)	O(nlogn)	O(nlogn)	O(n)	稳定
快速排序	O(nlogn)	O(nlogn)	O(n^2)	O(logn)-O(n)	不稳定

稳定性验证案例：

• 直接选择排序：{5，8，5，2，9}
  

由上图我们可以发现，第一个5的位置关系和第二个5的位置关系发生了变化，因此直接选择排序是不稳定的

• 希尔排序：{5，8，2，5，9}
  

由上图我们可以发现，第一个5的位置关系和第二个5的位置关系发生了变化，因此希尔排序是不稳定的

• 堆排序：{2，2，2，2}

由上图我们可以发现，输出的顺序为2(1)、2(4)、2(2)、2(3)，因此堆排序是不稳定的

• 快速排序：{5，3，3，4，3，8，9，10，11}

由上图我们可以发现，3的位置关系发生了变化，因此快速排序是不稳定的

测试代码：排序性能对比

让不同排序方式排序十万个随机生成的数据，观察排序时间

#include"sort.h"

void TestOP()
{
	srand(time(0));
	const int N = 100000;
    int* a1 = (int*)malloc(sizeof(int) * N);
    int* a2 = (int*)malloc(sizeof(int) * N);
    int* a3 = (int*)malloc(sizeof(int) * N);
    int* a4 = (int*)malloc(sizeof(int) * N);
    int* a5 = (int*)malloc(sizeof(int) * N);
    int* a6 = (int*)malloc(sizeof(int) * N);
    int* a7 = (int*)malloc(sizeof(int) * N);
    int* a8 = (int*)malloc(sizeof(int) * N);

    for (int i = 0; i < N; ++i)
    {
        a1[i] = rand();
        a2[i] = a1[i];
        a3[i] = a1[i];
        a4[i] = a1[i];
        a5[i] = a1[i];
        a6[i] = a1[i];
        a7[i] = a1[i];
        a8[i] = a1[i];
    }
    
    int begin1 = clock();
    InsertSort(a1, N);
    int end1 = clock();

    int begin2 = clock();
    ShellSort(a2, N);
    int end2 = clock();

    int begin3 = clock();
    SelectSort(a3, N);
    int end3 = clock();

    int begin4 = clock();
    HeapSort(a4, N);
    int end4 = clock();

    int begin5 = clock();
    QuickSort(a5, 0, N - 1);
    int end5 = clock();

    int begin6 = clock();
    MergeSort(a6, N);
    int end6 = clock();

    int begin7 = clock();
    BubbleSort(a7, N);
    int end7 = clock();

    int begin8 = clock();
    CountSort(a7, N);
    int end8 = clock();

    printf("InsertSort:%d\n", end1 - begin1);
    printf("ShellSort:%d\n", end2 - begin2);
    printf("SelectSort:%d\n", end3 - begin3);
    printf("HeapSort:%d\n", end4 - begin4);
    printf("QuickSort:%d\n", end5 - begin5);
    printf("MergeSort:%d\n", end6 - begin6);
    printf("BubbleSort:%d\n", end7 - begin7);
    printf("CountSort:%d\n", end8 - begin8);

    free(a1);
    free(a2);
    free(a3);
    free(a4);
    free(a5);
    free(a6);
    free(a7);
    free(a8);
}

int main()
{
	TestOP();
	return 0;
}