排序算法（二）

归并排序

归并排序思想

• 将一组数据递归式的平分为左，右两部分，如果左边部分有序，且右边部分有序，则将这两部分按照合并有序数组的思想将这两组数据合并，那么整体数据就是有序的了，从下图可以看出，将数据分成2份，所形成的是一个二叉树结构，在并的时候，每一层的时间复杂度都是O(n)，一共有logn层，所以归并排序的时间复杂度是标准的O(nlogn)，但是遗憾的是，归并排序需要额外开辟空间临时存储排好序的数据，所以归并排序的空间复杂度是O(n)，同时归并排序是一种稳定的排序，同时也是唯一的外排序
  

递归

递归式实现归并排序是好理解的，递归直接可以完成归和并这两步，不需要额外的操作，下面是归并排序的动图和代码。

void _MergeSort(int* arr, int left, int right, int* tmp)
{
	if (left >= right)
		return;

	int mid = (right + left) / 2;

	//对[left,mid],[mid+1,right]区间递归
	_MergeSort(arr, left, mid, tmp);
	_MergeSort(arr, mid+1,right,tmp);

	//归并
	int begin1 = left, end1 = mid;
	int begin2 = mid+1, end2 = right;
	int index = left;
	while (begin1 <= end1 && begin2 <= end2)
	{
		if (arr[begin1] < arr[begin2])
			tmp[index++] = arr[begin1++];
		else
			tmp[index++] = arr[begin2++];
	}
	// - 在插入完后，一定有一个数组还存在剩余元素，将剩余元素拷贝到临时数组中
	while (begin1 <= end1)
		tmp[index++] = arr[begin1++];

	while (begin2 <= end2)
		tmp[index++] = arr[begin2++];

	memmove(arr + left, tmp + left, sizeof(int) * (right - left + 1));
}

void MergeSort(int* arr, int n)
{
	int* tmp = (int*)malloc(sizeof(int) * n);
	if (tmp == NULL)
		return;
	int left = 0, right = n - 1;

	_MergeSort(arr,left, right, tmp);

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

非递归

归并排序的非递归写法，很多人认为要借用数据栈来实现，其实借用数据栈反而不好实现，因为数据栈只能模拟分割数据的过程，而不能模拟合并数据的过程，在非递归的实现中，我们可以手动数据分割，然后直接进行归并。

在归并排序非递归中，可能出现无法组成归并组的序列，如元素7，这些无法组成归并组的序列一定是有序的。同时，出现这些元素的本质是因为在非递归的归并排序中，存在3个索引可能越界，在下面代码注释中我会详细解释原因和解决方案。

void MergeSortNonR(int* arr, int n)
{
	int* tmp = (int*)malloc(sizeof(int) * n);
	if (tmp == NULL)
		return;
	// - **控制每组归并序列间的距离
	int gap = 1;

	// - 11归，22归，44归....
	while (gap < n)
	{
		// - 控制多组归并元素
		for (int i = 0; i < n; i+=2*gap)// - i每次要切换到下一个归并组，所以要跳过2组归并序列
		{
			// - end1,begin2,end2 会越界
			int begin1 = i, end1 = i + gap - 1;
			int begin2 = i+gap, end2 = i+2*gap-1;
			int index = i;
			// - begin2越界代表该归并组不完全，不需要归并，直接break。
			// - 只要begin2不存在，那么归并组就不完全，所以不需要判断end1。
			if (begin2 >= n)
				break;
			// - begin2存在，end2越界，代表第二组归并序列元素不全，虽然元素不全，但是归并组存在，依旧要归并
			// - 所以要改变end2的索引位置，
			if (end2 >= n)
				end2 = n - 1;
			while (begin1 <= end1 && begin2 <= end2)
			{
			if (arr[begin1] < arr[begin2])
				tmp[index++] = arr[begin1++];
			else
				tmp[index++] = arr[begin2++];
			}
			// - 在插入完后，一定有一个数组还存在剩余元素，将剩余元素拷贝到临时数组中
			while (begin1 <= end1)
				tmp[index++] = arr[begin1++];

			while (begin2 <= end2)
				tmp[index++] = arr[begin2++];

			memmove(arr + i, tmp + i, sizeof(int) * (end2-i + 1));

		}

		gap *= 2;

	}

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

快速排序

快速排序思想

• 快速排序也是一种基于二叉树的排序，设定一组数据的key值，在数组中寻找，将吧比key值大/小的数据按照排序要求交换到合适的位置，当要排查的元素只有最后一个时，那么那个位置就是key应该存在的位置，每趟快速排序得到的效果有2个。
  1.key值出现在了合适的位置。
  2.按照排序要求，所有比key大的值出现在key的左/右边，比key小的值出现在key的左/右边。
  同时在递归式的以排好的key值为分割线，分割待排序的空间，排序，时间复杂度一般为O(nlogn)，但当key值每次都是最小值或最大值时，将退化为O(n^2)，空间复杂度O(logn)，同时快速排序不是一种稳定的排序。

递归

快排的递归版本较为简单，重点是每一趟排序的代码，有多种写法，现在我展示一种双指针写法。

int PartSort(int* arr, int left, int right)
{
    // - keyi选择区间最左边的元素。
	int keyi = left;
	// - 两个指针，cur找小，prev后的所以元素一定小于arr[keyi]
	int cur = left + 1, prev = left;

	while (cur <= right)
	{
		// - 找小，prev == cur 不交换
		if (arr[cur] < arr[keyi] && ++prev != cur)
		{
			int tmp = arr[cur];
			arr[cur] = arr[prev];
			arr[prev] = tmp;
		}
		cur ++;
	}
	int tmp = arr[keyi];
	arr[keyi] = arr[prev];
	arr[prev] = tmp;

	return prev;
}

void QuickSort(int* arr, int left, int right)
{
	if (left >= right)
		return;

	int keyi = PartSort(arr, left, right);
	//[left,keyi-1] keyi [keyi+1,right]
	QuickSort(arr, left, keyi - 1);
	QuickSort(arr, keyi+1, right);


}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

非递归

快排非递归可以利用数据栈来实现，将待排序的部分压入数据栈中，不断探出待排序的区间，当栈为空时，就证明数据被排完。

void QuickSortNonR(int* arr, int n)
{
	ST st;
	STInit(&st);
	//压入待排序的区间
	STPush(&st, n-1);
	STPush(&st, 0);
	while (!STEmpty(&st))
	{
		
		int left = STTop(&st);
		STPop(&st);
		int right = STTop(&st);
		STPop(&st);
		int keyi = PartSort(arr, left, right);
		//压入右区间
		if (keyi + 1 < right)
		{
			STPush(&st, right);
			STPush(&st, keyi + 1);
		}
		//压入左区间
		if (left < keyi - 1)
		{
			STPush(&st, keyi - 1);
			STPush(&st, left);
		}
		//先压右，在压左，先pop出左，在pop出右
	}

	STDestroy(&st);

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

优化

快速排序的keyi如果每次都是最大值或最小值，则快速排序的时间复杂度将会降低为O(n^2)，为了防止keyi取到数据的最大值或最小值，可以加入一个三数取中代码。

// - 三数取中，最左边，最右边，最中间的数的中间的数
// - 返回中间数的下标，同时交换最左边的数和中间下标的数。
int GitMid(int* arr, int left, int right)
{
	int mid = (left + right) / 2;

	if (arr[left] < arr[right])
	{
		if (arr[right] < arr[mid])
			return right;
		else if (arr[mid] < arr[left])
			return left;
		else
			return mid;
	}
	else
	{
		if (arr[right] > arr[mid])
			return right;
		else if (arr[mid] > arr[left])
			return left;
		else
			return mid;
	}

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

同时，在快速排序的递归中，递归的层次越深，递归的数量越大，比如二叉树的最后一层占整个二叉树的50%，所以，在快速排序的递归中，可以对小区间进行优化，当区间较小时可以直接进行插入排序，可以稍微优化快速排序。

void QuickSort(int* arr, int left, int right)
{
	if (left >= right)
		return;
	if ((right - left + 1) > 10)
	{
		int keyi = PartSort(arr, left, right);
		QuickSort(arr,left,keyi-1);
		QuickSort(arr, keyi+1,right);
	}
	else
	{
		InsertSort(arr, right-left+1);
	}

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

计数排序

计数排序思想

• 计数排序的思想很简单，将待排序的数据中每个数据记录在与之映射的数组下标中，随后遍历映射数组排序。
• 计数排序有很多缺点，如无法排序浮点型，结构体…数据，计数排序的时间复杂度为O(n+k)，k为映射数组的大小，空间复杂度为O(k)。

void CountSort(int* a, int n)
{
	// -找到最大值，最小值，创建映射数组
	int min = a[0], max = a[0];
	for (size_t i = 0; i < n; i++)
	{
		if (a[i] < min)
			min = a[i];

		if (a[i] > max)
			max = a[i];
	}
	//range为映射数组的大小
	int range = max - min + 1;
	int* count = (int*)malloc(sizeof(int) * range);
	printf("range:%d\n", range);
	if (count == NULL)
	{
		perror("malloc fail");
		return;
	}
	memset(count, 0, sizeof(int) * range);

	// 统计数据出现次数
	for (int i = 0; i < n; i++)
	{
		count[a[i] - min]++;
	}

	// 排序
	int j = 0;
	for (int i = 0; i < range; i++)
	{
		while (count[i]--)
		{
			//加上映射值
			a[j++] = i + min;
		}
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40