常用比较排序和计数排序(总结)

1排序的概念与运用

1.1排序的概念

排序：所谓排序，就是使一串记录，按照其中的某个或某些关键字的大小，递增或递减的排列起来的操作。
稳定性：假定在待排序的记录序列中，存在多个具有相同的关键字的记录，若经过排序，这些记录的相对次序保持不变，即在原序列中，r[i]=r[j]，且r[i]在r[j]之前，而在排序后的序列中，r[i]仍在r[j]之前，则称这种排序算法是稳定的；否则称为不稳定的。
内部排序：数据元素全部放在内存中的排序。
外部排序：数据元素太多不能同时放在内存中，根据排序过程的要求不能在内外存之间移动数据的排序。

1.2排序的运用

2排序的算法实现

2.1插入排序

2.1.1直接插入排序

基本思想：
把待排序的记录按其关键码值的大小逐个插入到一个已经排好序的有序序列中，直到所有的记录插入完为止，得到一个新的有序序列 。

//插入排序
void InsertSort(int* arr, int n)
{
	assert(arr);
	for (int i = 0; i < n - 1; i++)
	{
		int end = i;
		int temp = arr[end + 1];
		while (end >= 0)
		{
			if (temp > arr[end])
			{
				arr[end + 1] = arr[end];
				--end;
			}
			else
			{
				break;
			}
		}
		arr[end + 1] = temp;
	}
}

时间和空间复杂度分析：
时间复杂度：
第一次需要将一个数据插入1个已经排好序的数据，最多需要比较1次，最少也是一次，第二次需要将一个数据插入前两个已经排好序的数据，最多需要比较两次，最少比较一次，所以，以此类推，第n次需要把一个数据插入前n - 1个有序数据，最多需要比较n -1次，最少一次
所以最好时间复杂度为O(n),最坏为1 + 2 + 3 +4 + … + n - 1 为等差数列求和即 O(n^2)
空间复杂度：
只开辟了常数级空间，空间复杂度为O(1).

2.1.2希尔排序

希尔排序法又称缩小增量法。希尔排序法的基本思想是：先选定一个整数，把待排序文件中所有记录分成个组，所有距离为的记录分在同一组内，并对每一组内的记录进行排序。然后，取，重复上述分组和排序的工作。当到达=1时，所有记录在统一组内排好序。

1. 希尔排序是对直接插入排序的优化。
2. 当gap > 1时都是预排序，目的是让数组更接近于有序。当gap == 1时，数组已经接近有序的了，这样就
   会很快。这样整体而言，可以达到优化的效果。我们实现后可以进行性能测试的对比。
3. 希尔排序的时间复杂度不好计算，因为gap的取值方法很多，导致很难去计算，因此在好些树中给出的希尔排序的时间复杂度都不固定：
4. 空间复杂度为O(1)

2.2选择排序

2.2.1直接选择排序

基本思想：
每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，直到全部待排序的数据元素排完 。

void SelectSort(int* arr, int n)
{
	assert(arr);
	int begin = 0, end = n - 1;
	while (begin < end)
	{
		int mini = begin;
		int maxi = begin;
		for (int i = begin; i <= end; i++)
		{
			if (arr[i] > arr[maxi])
			{
				maxi = i;
			}
			if (arr[i] < arr[mini])
			{
				mini = i;
			}
		}
		Swap(&arr[mini], &arr[end]);
		//当最大的数据在末尾时，把最小的数据和末尾数据交换时，把它交换到了最小元素的下标处，所以需要更换最大元素的下标
		if (maxi == end)
		{
			maxi = mini;
		}
		Swap(&arr[maxi], &arr[begin]);
		++begin;
		--end;
	}
}

时间复杂度：O(n^2)
空间复杂度：O(1)

2.2.2堆排序

堆排序(Heapsort)是指利用堆积树（堆）这种数据结构所设计的一种排序算法，它是选择排序的一种。它是
通过堆来进行选择数据。需要注意的是排升序要建大堆，排降序建小堆。

//向下调整算法
void AdjustDown(int* arr, int n, int root)
{
	int parent = root;
	int child = parent * 2 + 1;
	while (child < n)
	{
		if (child + 1 < n && arr[child + 1] < arr[child])
			child++;
		if (arr[parent] < arr[child])
		{
			break;
		}
		else
		{
			Swap(&arr[parent], &arr[child]);
			parent = child;
			child = parent * 2 + 1;
		}
	}
}
void HeapSort(int* arr, int n)
{
	assert(arr);
	//建堆
	for (int i = (n - 1 - 1) / 2; i >= 0; i--)
	{
		AdjustDown(arr, n, i);
	}
	//每次建好堆了，最小的数据在最上面，把它和末尾数据交换
	//然后减小堆的大小，继续向下调整，此时最小的数据又在最上面，重复以上动作即可
	Swap(&arr[0], &arr[n - 1]);
	for (int i = n - 1; i > 1; --i)
	{
		AdjustDown(arr, i, 0);
		Swap(&arr[0], &arr[i - 1]);
	}
}

时间复杂度：

建堆之后，不断交换堆顶数据，和向下调整，由图可以知道时间复杂度为nlogn，
所以总体时间复杂度为O(n*logn).
空间复杂度：O(1)

2.3交换排序

2.3.1冒泡排序

每次从头到未交换数据，交换到尾时，最大或最小的在最后，然后缩小交换范围，范围减小一个，然后重复即可，直接只有一个数据。

void BubbleSort(int* arr, int n)
{
	assert(arr);
	int end = n - 1;
	while (end > 0)
	{
		int change = 0;
		for (int i = 0; i < end; i++)
		{
			if (arr[i] < arr[i + 1])
			{
				Swap(&arr[i], &arr[i + 1]);
				change = 1;
			}
		}
		if (change == 0)
		{
			break;
		}
	}
}

时间复杂度：O(n^2)
空间复杂度：O(1)

2.3.3快速排序

快速排序是Hoare于1962年提出的一种二叉树结构的交换排序方法，其基本思想为：任取待排序元素序列中
的某元素作为基准值，按照该排序码将待排序集合分割成两子序列，左子序列中所有元素均小于基准值，右
子序列中所有元素均大于基准值，然后最左右子序列重复该过程，直到所有元素都排列在相应位置上为止。
// 假设按照升序对array数组中[left, right)区间中的元素进行排序

void QuickSort(int array[], int left, int right)
{
 if(right - left <= 1)
 return;
 
 // 按照基准值对array数组的 [left, right)区间中的元素进行划分
 int mid = partion(array, left, right);
 
 // 划分成功后以mid为边界形成了左右两部分 [left, mid - 1] 和 [div+1, right)
 // 递归排[left, mid - 1]
 QuickSort(array, left, mid - 1);
 
 // 递归排[mid+1, right)
 QuickSort(array, mid +  1, right);
}

上述为快速排序递归实现的主框架，发现与二叉树前序遍历规则非常像，同学们在写递归框架时可想想二叉
树前序遍历规则即可快速写出来，后序只需分析如何按照基准值来对区间中数据进行划分的方式即可。
将区间按照基准值划分为左右两半部分的常见方式有：

快速排序优化

1. 三数取中法选key
2. 递归到小的子区间时，可以考虑使用插入排序

代码实现：

//快速排序递归版
void QuickSort(int* arr, int n)
{
	assert(arr);
	_QuickSort(arr, 0, n - 1);
}
int GetMidIndex(int* arr, int left, int right)
{
	int mid = (left + right) / 2;
	if (arr[right] > arr[mid])
	{
		if (arr[mid] > arr[left])
		{
			return mid;
		}
		else if (arr[right] > arr[left])
		{
			return left;
		}
		else
		{
			return right;
		}
	}
	else
	{
		if (arr[right] > arr[left])
		{
			return right;
		}
		else if (arr[left] > arr[mid])
		{
			return mid;
		}
		else
		{
			return left;
		}
	}
}
void _QuickSort(int* arr, int left, int right)
{
	if (left >= right)
		return;
	if (right - left < 10)
	{
		InsertSort(arr + left, right - left + 1);
		return;
	}
	int mid = PartSort3(arr, left, right);
	_QuickSort(arr, left, mid - 1);
	_QuickSort(arr, mid + 1, right);
}
//左右指针法
int PartSort1(int* arr, int left, int right)
{
	int midIndex = GetMidIndex(arr, left, right);
	Swap(&arr[midIndex], &arr[right]);
	int keyi = right;
	while (left < right)
	{
		while (left < right && arr[left] >= arr[keyi])
			left++;
		while (left < right && arr[right] <= arr[keyi])
			right--;
		Swap(&arr[left], &arr[right]);
	}
	Swap(&arr[left], &arr[keyi]);
	return left;
}
//挖坑法
int PartSort2(int* arr, int left, int right)
{
	int midIndex = GetMidIndex(arr, left, right);
	Swap(&arr[midIndex], &arr[right]);
	int key = arr[right];
	while (left < right)
	{
		while (left < right && arr[left] >= key)
			left++;
		arr[right] = arr[left];
		while (left < right && arr[right] <= key)
			right--;
		arr[left] = arr[right];
	}
	arr[left] = key;
	return left;
}
//前后指针法
int PartSort3(int* arr, int left, int right)
{
	int midIndex = GetMidIndex(arr, left, right);
	Swap(&arr[midIndex], &arr[right]);
	int prev = left - 1;
	int cur = left;
	int keyi = right;
	while (cur < right)
	{
		if (arr[cur] > arr[keyi] && ++prev != cur)
		{
			Swap(&arr[prev], &arr[cur]);
		}
			cur++;
		
	}
	++prev;
	Swap(&arr[prev], &arr[keyi]);
	return prev;
}

//快排非递归
void QuickSortNonR(int* arr, int n)
{
	Stack st;
	StackInit(&st);
	StackPush(&st, 0);
	StackPush(&st, n - 1);
	while (!StackEmpty(&st))
	{
		int right = StackTop(&st);
		StackPop(&st);
		int left = StackTop(&st);
		StackPop(&st);
		if (right > left)
		{
			if (right - left < 10)
			{
				InsertSort(arr, n);
			}
			else
			{
				int mid = PartSort1(arr, left, right);
				StackPush(&st, mid + 1);
				StackPush(&st, right);
				StackPush(&st, left);
				StackPush(&st, mid - 1);
			}
			
		}
		StackDestroy(&st);
	}
}
void StackInit(Stack* ps)
{
	assert(ps);
	ps->val = NULL;
	ps->size = ps->capacity = 0;
}
void StackDestroy(Stack* ps)
{
	assert(ps);
	free(ps->val);
	ps->val = NULL;
	ps->size = ps->capacity = 0;
}
void StackPush(Stack* ps, STDateType x)
{
	assert(ps);
	if (ps->size == ps->capacity)
	{
		ps->capacity = ps->capacity == 0 ? 2 : ps->capacity * 2;
		STDateType* temp = (STDateType*)realloc(ps->val, ps->capacity * sizeof(STDateType));
		if (temp == NULL)
			exit(-1);
		ps->val = temp;
	}
	ps->val[ps->size] = x;
	++(ps->size);
}
void StackPop(Stack* ps)
{
	assert(ps && ps->size > 0);
	--(ps->size);
}
STDateType StackTop(Stack* ps)
{
	assert(ps && ps->size > 0);
	return ps->val[ps->size - 1];
}
bool StackEmpty(Stack* ps)
{
	assert(ps);
	return ps->size == 0;
}

快速排序未优化
时间复杂度O(nlogn ~ n ^ 2)
空间复杂度(logn ~ n)
优化后
时间复杂度O(nlogn)
空间复杂度(logn)

2.4外排序

2.4.1归并排序

归并排序（MERGE-SORT）是建立在归并操作上的一种有效的排序算法,该算法是采用分治法（Divide and
Conquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有
序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。
ng)
代码：

//归并排序
void MergeSort(int* arr, int n)
{
	assert(arr);
	int* temp = (int*)malloc(sizeof(int) * n);
	_MergeSort(arr, 0, n - 1, temp);
	free(temp);
}
void _MergeSort(int* arr, int left, int right, int* temp)
{
	assert(arr && temp);
	if (left < right)
	{
		int mid = (left + right) / 2;
		_MergeSort(arr, left, mid, temp);
		_MergeSort(arr, mid + 1, right, temp);
		int begin1 = left, end1 = mid;
		int begin2 = mid + 1, end2 = right;
		MergeArr(arr, begin1, end1, begin2, end2, temp);
	}
}
void MergeArr(int* arr, int begin1, int end1, int begin2, int end2, int* temp)
{
	int index = begin1;
	int head = begin1;
	int tail = end2;
	while (begin1 <= end1 || begin2 <= end2)
	{
		if (begin1 > end1)
		{
			temp[index++] = arr[begin2++];
		}
		else if (begin2 > end2)
		{
			temp[index++] = arr[begin1++];
		}
		else if (arr[begin1] < arr[begin2])
		{
			temp[index++] = arr[begin2++];
		}
		else
		{
			temp[index++] = arr[begin1++];
		}
	}
	memcpy(arr + head, temp + head, sizeof(int) * (tail - head + 1));

}
//归并排序非递归
void MergeSortNonR(int* arr, int n)
{
	assert(arr);
	int gap = 1;
	int* temp = (int*)malloc(sizeof(int) * n);
	while (gap < n)
	{
		for (int i = 0; i < n; i += 2 * gap)
		{
			int begin1 = i, end1 = i + gap - 1;
			int begin2 = i + gap, end2 = i + 2 * gap - 1;
			if (begin2 >= n)
			{
				break;
			}
			if (end2 >= n)
			{
				end2 = n - 1;
			}
			MergeArr(arr, begin1, end1, begin2, end2, temp);
		}
		gap *= 2;
	}
	free(temp);
}

时间复杂度O(n*logn)
空间复杂度O(logn)

2.4.2外排序的应用

处理海量数据：当数据太多无法一次性加载进内存时候，内排序就不能用了。
比如一个文件一共有一百数据，我们可以把他们分成10份，每次加载10个数据进入内存，然后用快速排序排序，再把它们放到不同的文件里，然后把这些文件使用外排序排序

//海量数据文件排序
void MergeFileSort(const char* fileName)
{
	FILE* fin = fopen(fileName, "r");
	if (fin == NULL)
	{
		printf("open file fail\n");
		exit(-1);
	}
	int arr[10];
	int i = 0;
	int n = 10;
	int fileNum = 1;
	char subFileName[100];
	int num = 0;
	while (fscanf(fin, "%d\n", &num) != EOF)
	{
		//读取10个数
		if (i < n)
		{
			arr[i++] = num;
		}
		//把读取的书在内存中排序后写入文件
		if (i == n)
		{
			QuickSort(arr, 10);
			sprintf(subFileName, "%d", fileNum++);
			FILE* fout = fopen(subFileName, "w");
			if (fout == NULL)
			{
				printf("open file fail\n");
				exit(-1);
			}
			for (int i = 0; i < n; ++i)
			{
				fprintf(fout, "%d\n", arr[i]);
			}
			fclose(fout);
			i = 0;
		}
	}
	fclose(fin);
	//文件归并
	char file1[20] = "1";
	char file2[20] = "2";
	char mfile[20] = "12";
	for (int i = 2; i <= n; ++i)
	{
		_MergeFileSort(file1, file2, mfile);
		strcpy(file1, mfile);
		sprintf(file2, "%d", i + 1);
		sprintf(mfile, "%s%d", mfile, i + 1);
	}
	
}
void _MergeFileSort(const char* file1, const char* file2, const char* mfile)
{
	int num1 = 0;
	int num2 = 0;
	FILE* fin1 = fopen(file1, "r");
	if (fin1 == NULL)
	{
		printf("open file fail\n");
		exit(-1);
	}
	FILE* fin2 = fopen(file2, "r");
	if (fin2 == NULL)
	{
		printf("open file fail\n");
		exit(-1);
	}
	FILE* fout = fopen(mfile, "w");
	if (fout == NULL)
	{
		printf("open file fail\n");
		exit(-1);
	}
	int ret1 = fscanf(fin1, "%d\n", &num1);
	int ret2 = fscanf(fin2, "%d\n", &num2);
	while (ret1 != EOF || ret2 != EOF)
	{
		if (ret1 == EOF)
		{
			fprintf(fout, "%d\n", num2);
			ret2 = fscanf(fin2, "%d\n", &num2);
		}
		else if (ret2 == EOF)
		{
			fprintf(fout, "%d\n", num1);
			ret1 = fscanf(fin1, "%d\n", &num1);
		}
		else if (num1 > num2)
		{
			fprintf(fout, "%d\n", num1);
			ret1 = fscanf(fin1, "%d\n", &num1);
		}
		else
		{
			fprintf(fout, "%d\n", num2);
			ret2 = fscanf(fin2, "%d\n", &num2);
		}
	}
	fclose(fin1);
	fclose(fin2);
	fclose(fout);
}

2.5计数排序

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

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

//计数排序
void CountSort(int* arr, int n)
{
	assert(arr);
	int min = arr[0];
	int max = arr[0];
	for (int i = 0; i < n; ++i)
	{
		if (arr[i] > max)
		{
			max = arr[i];
		}
		if (arr[i] < min)
		{
			min = arr[i];
		}
	}
	int range = max - min + 1;
	int* countArr = (int*)malloc(sizeof(int) * range);
	memset(countArr, 0, sizeof(int) * range);
	for (int i = 0; i < n; ++i)
	{
		countArr[arr[i] - min]++;
	}
	int index = 0;
	for (int i = 0; i < range; ++i)
	{
		while (countArr[i]--)
		{
			arr[index++] = i + range;
		}
	}
}

计数排序的特性总结：
3. 计数排序在数据范围集中时，效率很高，但是适用范围及场景有限。
4. 时间复杂度：O(MAX(N,范围))
5. 空间复杂度：O(范围)

三，排序时间复杂度与稳定性