• 数据结构：排序- 插入排序(插入排序and希尔排序) , 选择排序(选择排序and堆排序) , 交换排序(冒泡排序and快速排序) , 归并排序

    目录

    前言

    复杂度总结

    预备代码

    插入排序

    1.直接插入排序: 时间复杂度O(N^2) \空间复杂度O(1)

    复杂度（空间/时间）：

    2.希尔排序： 时间复杂度 O(N^1.3~ N^2） 空间复杂度为O(1)

    复杂度（空间/时间）：

    选择排序

    1.直接选择排序 时间复杂度O(N^2)/空间复杂度O(1)

    复杂度（空间/时间）：

    2.堆排序： 时间复杂度O(N*logN) /空间复杂度O(1)

    复杂度（空间/时间）：

    交换排序

    1.冒泡排序: 时间复杂度O(N^2)/空间复杂度O(1)

    复杂度（空间/时间）：

    2.快速排序

    2.1. hoare版本 时间复杂度为O(n)/空间复杂度为O(1)​编辑

    2.2. 挖坑法 相比hoare本质上并没有简化复杂度​编辑

    2.3. 前后指针法​编辑

    2.4三数取中:

    2.5快排主体 &&小区间优化

    快排主体 &&小区间优化

    复杂度（空间/时间）：

    将快速排序改为非递归

    归并排序

    复杂度（空间/时间）：

    归并排序非递归实现

    方法一 ：修正边界法​编辑

    方法二 ：

    全部功能测试

    全部代码

    头文件

    1.Sort.h

    2.Stack.h

    函数实现文件

    1.Sort.c

    2.QuickSort.c

    3.Heap.c

    4.Stack.c

    测试函数

    test.c

    前言

    在数据结果中：常见排序一共分为四种

    1. 插入排序（直接插入排序，希尔排序）
    2. 选择排序（选择排序，堆排序）
    3. 交换排序（冒泡排序，快速排序）
    4. 归并排序

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


    本文将对这些排序进行详细讲解

    复杂度总结

    表中 平均情况and最好情况and最坏情况都是讨论时间复杂度：

    排序方法平均情况最好情况最坏情况空间复杂度稳定性
    冒泡排序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(nlogn)O(nlogn)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)不稳定

    预备代码

    1. //打印
    2. void PrintArry(int* a, int n)
    3. {
    4. 	for (int i = 0; i < n; i++)
    5. 		printf("%d ",a[i]);
    6.  
    7. 	printf("\n");
    8. }
    9.  
    10. //交换
    11. void Swap(int* p1, int* p2)
    12. {
    13. 	int tmp = *p1;
    14. 	*p1 = *p2;
    15. 	*p2 = tmp;
    16. }

    插入排序

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

    1.直接插入排序: 时间复杂度O(N^2) \空间复杂度O(1)

    直接插入排序的思想是将待排序的元素逐个插入已经排好序的序列中，直到全部元素都插入完毕。它通过比较元素大小，找到正确的插入位置，并插入到该位置。这样不断重复，直到完成排序。它是一种简单且稳定的排序算法，适用于小规模数据或已经基本有序的数据。

    • 思想：

      1.先将第0个记录，组成一个有序子表
      2.然后依次将后面的记录插入到这个子表中，且一直保持它的有序性。

    • 步骤

    1. 在r[0…i-1]中查找r[i]的插入位置，r[0…j].key ≤r[i].key < r[j+1…i-1].key

    2. 将r[j+1 … i-1] 中的所有记录均后移一个位置

    3. 将r[i]插入到r[j+1]的位置上

    算法实现：

    1. //直接插入排序
    2. // 一个数一次向后比较一个元素，当比该数字小时，后面元素后移，后插入该数
    3. void InsertSort(int* a, int n)
    4. {
    5. 	for (int i = 0; i < n - 1; i++)
    6. 	{
    7. 		// [0,end]有序，吧end+1 位置的值插入，保持有序
    8. 		int end = i;
    9. 		int tmp = a[end + 1];
    10. 		while (end >= 0)
    11. 		{
    12. 			if (tmp < a[end])//要交换的数字更大
    13. 			{
    14. 				//指针指向元素后移，end指针前移
    15. 				a[end + 1] = a[end];
    16. 				--end;
    17. 			}
    18. 			else
    19. 			{
    20. 				//要交换的数字更小,退出循环
    21. 				break;
    22. 			}
    23. 		}
    24. 		//开始交换
    25. 		a[end + 1] = tmp;
    26. 	}
    27. }

    测试:

    1. void TestInsertSort()
    2. {
    3. 	int a[] = { 9,1,2,5,7,4,8,6,3,5 };
    4. 	int sz = sizeof(a) / sizeof(a[0]);
    5. 	InsertSort(a, sz);
    6. 	PrintArry(a, sz);
    7. }

    直接插入排序的特性总结：

    1. 元素集合越接近有序，直接插入排序算法的时间效率越高
    2. 时间复杂度：O(N^2)
    3. 空间复杂度：O(1)，它是一种稳定的排序算法
    4. 稳定性：稳定

    复杂度（空间/时间）：

    时间复杂度:

    • 最好情况下，即输入序列已经按升序排好顺序，直接插入排序的时间复杂度为O(n)，其中n是待排序序列的长度。因为此时插入一个元素时，只需比较一次即可确定插入位置。
    • 最坏情况下，即输入序列是降序排列，直接插入排序的时间复杂度为O(n^2)。因为此时每个元素都需要与前面的所有元素比较，找到正确的插入位置。
    • 平均情况下，直接插入排序的时间复杂度也是O(n^2)。这是因为每个元素的平均比较次数为n/2，而平均移动次数为n/4。

    空间复杂度:
    直接插入排序的空间复杂度为O(1)。直接插入排序是一种原地排序算法，它只需要常数级别的额外空间来存储临时变量，不需要开辟额外的存储空间。

    需要注意的是，直接插入排序是一种稳定的排序算法。相等元素的相对顺序不会被改变。虽然直接插入排序的时间复杂度较高，但在对小规模数据或基本有序的数据进行排序时，它是一种简单而有效的选择。

    2.希尔排序： 时间复杂度 O(N^1.3~ N^2） 空间复杂度为O(1)

    希尔排序是一种改进的插入排序算法。它通过将待排序的元素按一定间隔分组，对每个分组进行插入排序，然后逐步缩小间隔，重复这个过程，直到间隔为1。希尔排序通过跳跃式的比较和移动元素，可以在某种程度上提前将较小的元素移动到前面，从而大致有序，最后再进行一次插入排序完成排序。希尔排序的时间复杂度不是固定的，但通常情况下具有较高的效率。

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


    gap越大，所排列的有序性越差，故gap不易过大
    算法实现：

    1. void ShellSort(int* a, int n)
    2. {
    3. 	int gap = n;
    4. 	while (gap > 1)
    5. 	{
    6. 		gap = gap / 3 + 1;// gap/3:保证每次跳跃的间隔. +1：保证不为0
    7.  
    8. 		//gap组交替进行排序
    9. 		/*
    10. 		gap越大大的数更快到后面,小的数可以更快到前面
    11. 		排升序,gap越小,越接近有序,当gap==1,就是插入排序
    12. 		*/
    13. 		for (int i = 0; i < n - gap; i++)//往前走一位,gap另一部分	
    14. 		{
    15. 			int end = i;
    16. 			int tmp = a[end + gap];
    17.  
    18. 			while (end >= 0)
    19. 			{
    20. 				if (tmp < a[end])
    21. 				{
    22. 					//排序
    23. 					a[end + gap] = a[end];
    24. 					end -= gap;
    25. 				}
    26. 				else
    27. 					break;
    28. 			}
    29. 			a[end + gap] = tmp;//交换元素值
    30. 		}
    31. 	}
    32. }

    测试

    1. void TestShellSort()
    2. {
    3. 	int a[] = { 9,8,7,6,5,4,3,2,1,0 };
    4. 	int sz = sizeof(a) / sizeof(a[0]);
    5.  
    6. 	ShellSort(a, sz);
    7. 	PrintArry(a, sz);
    8. }

    希尔排序的特性总结：

    1. 希尔排序是对直接插入排序的优化。
    2. 当gap > 1时都是预排序，目的是让数组更接近于有序。当gap == 1时，数组已经接近有序的
      了，这样就会很快。这样整体而言，可以达到优化的效果。我们实现后可以进行性能测试的
      对比。
    3. 希尔排序的时间复杂度不好计算，需要进行推导，推导出来平均时间复杂度： O(N^1.3—
      N^2）
    4. 稳定性：不稳定

    复杂度（空间/时间）：

    时间复杂度：
    希尔排序的时间复杂度取决于所选择的增量序列。在最坏的情况下，希尔排序的时间复杂度为O(n^2){ O(N^1.3~ N^2）}，其中n是待排序序列的长度。但是在一般情况下，希尔排序的时间复杂度可以达到O(nlogn)。这是因为希尔排序通过逐步缩小增量，先对较远距离的元素进行比较和移动，使得序列整体趋于有序，然后再逐步缩小增量，最后进行一次增量为1的插入排序，这样减少了比较和移动的次数，提高了排序效率。

    空间复杂度：
    希尔排序的空间复杂度为O(1)，即常数级别的额外空间。希尔排序是一种原地排序算法，不需要额外开辟新的空间来存储临时变量或中间结果。所有的操作都是在输入序列上进行的，所以空间复杂度非常低。

    选择排序

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

    1.直接选择排序 时间复杂度O(N^2)/空间复杂度O(1)

    直接选择排序是一种简单的排序算法，通过不断选择最小（或最大）的元素，并将其放到已排序部分的末尾。这个过程在每次遍历中交换元素位置，直到整个序列有序。
    步骤：

    • 在元素集合array[i]–array[n-1]中选择关键码最大(小)的数据元素若它不是这组元素中的最后一个(第一个)元素，则将它与这组元素中的最后一个（第一个）元素交换
    • 在剩余的array[i]–array[n-2]（array[i+1]–array[n-1]）集合中，重复上述步骤，直到集合剩余1个元素

      算法实现：
    1. //对比插入排序，还是插入排序更优
    2. void SelectSort(int* a, int n)
    3. {
    4. 	assert(a);
    5. 	//遍历一遍选出最小and最大的，分别放在左右边
    6. 	int begin = 0, end = n - 1;
    7. 	int mini = begin, maxi = begin;
    8. 	while (begin
    9. 	{
    10. 		for (int i = 0; i <= end; i++)
    11. 		{
    12. 			//选最小
    13. 			if (a[i] < a[mini])
    14. 				mini = i;
    15. 			
    16. 			//选最大
    17. 			if (a[i] > a[maxi])
    18. 				maxi = i;
    19. 		}
    20.  
    21. 		Swap(&a[begin], &a[mini]);//交换元素
    22.  
    23. 		//如果begin和maxi重叠，那么需要修正位置
    24. 		if (begin == maxi)
    25. 			maxi = mini;
    26.  
    27. 		Swap(&a[end], &a[maxi]);//交换元素
    28. 		++begin;
    29. 		--end;
    30. 	}
    31. }

    直接选择排序的特性总结：

    1. 直接选择排序思考非常好理解，但是效率不是很好。实际中很少使用
    2. 时间复杂度：O(N2)
    3. 空间复杂度：O(1)
    4. 稳定性：不稳定

    复杂度（空间/时间）：

    直接选择排序的时间复杂度是O(n^2)，其中n是待排序序列的长度。具体来说，每次在未排序部分中查找最小元素，需要进行n-1次比较；然后将最小元素与已排序部分的最后一个元素交换位置，需要进行n-1次交换操作。因此，总共需要进行(n-1) + (n-2) + … + 2 + 1 = n(n-1)/2 次比较和交换，即时间复杂度为O(n^2)。
    直接选择排序的空间复杂度是O(1)，即只需要存储少量的辅助变量来进行比较和交换操作，不需要额外开辟存储空间。
    需要注意的是，直接选择排序是一种不稳定的排序算法，因为相等元素之间的相对顺序可能发生改变。在实际应用中，如果对稳定性有要求，可能会选择其他排序算法。

    2.堆排序： 时间复杂度O(N*logN) /空间复杂度O(1)

    堆排序详细讲解：# 数据结构：树和二叉树之-堆排列 (万字详解)
    1， 将数据插入堆中，造成大堆


    2，Pop k次


    算法实现：

    1. //向下调整
    2. void AdjustDown(int* a, int size, int parent)
    3. {
    4. 	int child = parent * 2 + 1;
    5. 	while (child < size)
    6. 	{
    7. 		if (child + 1 < size && a[child + 1] > a[child])
    8. 			++child;
    9.  
    10. 		//跟孩子父亲比较
    11. 		if (a[child] > a[parent])
    12. 		{
    13. 			Swap(&a[child], &a[parent]);
    14. 			parent = child;
    15. 			child = parent * 2 + 1;
    16. 		}
    17. 		else
    18. 		{
    19. 			//左右孩子都大于/小于父亲，结束交换
    20. 			break;
    21. 		}
    22. 	}
    23. }
    24.  
    25. //堆排序
    26. void HeapSort(int* a, int n)
    27. {
    28. 	//时间复杂度：O(N)
    29. 	for (int i = (n - 1) / 2; i >= 0; i--)
    30. 		AdjustDown(a, n, i);
    31.  
    32. 	int end = n - 1;
    33. 	while (end > 0)
    34. 	{
    35. 		Swap(&a[0], &a[end]);
    36. 		AdjustDown(a, end, 0);
    37. 		--end;
    38. 	}
    39. }

    测试：

    1. void TestHeapSort()
    2. {
    3. 	int a[] = { 9,8,7,6,5,4,3,2,1,0 };
    4. 	int sz = sizeof(a) / sizeof(a[0]);
    5.  
    6. 	HeapSort(a, sz);
    7. 	PrintArry(a, sz);
    8. }

    堆排序的特性总结：

    1. 堆排序使用堆来选数，效率就高了很多。
    2. 时间复杂度：O(N*logN)
    3. 空间复杂度：O(1)
    4. 稳定性：不稳定

    复杂度（空间/时间）：

    堆排序的时间复杂度为O(nlogn)，其中n是待排序序列的长度。

    • 建立最大堆的过程需要进行(n/2)次向下调整操作，每次调整的时间复杂度是O(logn)，所以 建立最大堆的过程需要进行(n/2)次向下调整操作，每次调整的时间复杂度是O(logn)，所以建立最大堆的时间复杂度是O(nlogn/2)，即简化为O(nlogn)。
    • 接下来，需要进行n-1次交换和调整堆的操作。每次交换后需要向下调整堆，调整的时间复杂度为O(logn)。所以这部分的时间复杂度也是O(nlogn)。
    • 综上所述，堆排序的时间复杂度为O(nlogn)。

    堆排序的空间复杂度为O(1)，因为它只需要使用常数级别的额外空间进行排序操作，不需要额外开辟存储空间。

    交换排序

    基本思想：所谓交换，就是根据序列中两个记录键值的比较结果来对换这两个记录在序列中的位置，交换排序的特点是：将键值较大的记录向序列的尾部移动，键值较小的记录向序列的前部移动。

    1.冒泡排序: 时间复杂度O(N^2)/空间复杂度O(1)

    冒泡排序是一种简单而直观的排序算法。它重复地比较相邻的两个元素，并将它们交换位置，直到整个序列按照从小到大（或从大到小）的顺序排列。
    冒泡排序的基本思想是通过不断地交换相邻元素的位置，将最大（或最小）的元素逐渐“冒泡”到序列的末尾。在每一轮的比较过程中，如果发现相邻元素的顺序错误，就将它们交换位置。这样，经过多轮的比较和交换，最终整个序列就会排序完成。


    算法实现：

    1. //冒泡排序  时间复杂度O(N^2),最坏情况还为O(N^2)
    2. //对比插入排序哪个更好？--接近有序或局部有序时，插入排序能更好适应
    3. void Bubblesort(int* a, int n)
    4. {
    5. 	assert(a);
    6.  
    7. 	for (int j = 0; j < n; j++)
    8. 	{
    9. 		int exchange = 0;
    10. 		for (int i = 0; i < n - j; i++)
    11. 		{
    12. 			if (a[i - 1] > a[i])
    13. 			{
    14. 				Swap(&a[i - 1], &a[i]);
    15. 				exchange = 1;
    16. 			}
    17. 		}
    18. 		if (exchange == 0)
    19. 			break;
    20. 	}
    21. }

    测试：

    1. void TestBubbleSort()
    2. {
    3. 	int a[] = { 9,8,7,6,5,4,3,2,1,0 };
    4. 	int sz = sizeof(a) / sizeof(a[0]);
    5.  
    6. 	Bubblesort(a, sz);
    7. 	PrintArry(a, sz);
    8. }

    冒泡排序的特性总结：

    1. 冒泡排序是一种非常容易理解的排序
    2. 时间复杂度：O(N^2)
    3. 空间复杂度：O(1)
    4. 稳定性：稳定

    复杂度（空间/时间）：

    冒泡排序的时间复杂度是O(n2)，其中n表示待排序序列的长度。这是因为冒泡排序在最坏的情况下需要进行n-1轮的比较和交换操作，每一轮需要比较n-i次，其中i为当前轮数。因此，总的比较次数为(n-1)+(n-2)+…+1，等于(n2 - n)/2，即O(n2)。
    冒泡排序的空间复杂度是O(1)，因为它只需要使用常量级的额外空间来存储临时变量和进行元素交换

    2.快速排序

    快速排序是一种排序算法，它通过不断地将序列分割成较小的部分并进行递归排序，最终实现整个序列的排序。它的核心思想是通过选择基准元素，并将比基准小的元素放在左边，比基准大的元素放在右边，然后对左右两个子序列进行递归排序。最终，所有子序列排序完成后，整个序列就有序了。

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

    三种方法：

    1. hoare版本
    2. 挖坑法 相比hoare本质上并没有简化复杂度
    3. 前后指针法

    2.1. hoare版本 时间复杂度为O(n)/空间复杂度为O(1)

    1. int PartSort1(int* a, int begin, int end)
    2. {
    3.     // 区间不存在，或者只有一个值则不需要再处理
    4.     if (begin >= end)
    5.         return; // 返回值类型应该是void，不需要返回具体的值
    6.  
    7.     int left = begin, right = end;
    8.     int keyi = left; // 取begin作为基准元素的下标
    9.  
    10.     while (left < right)
    11.     {
    12.         // 右边先走，找小
    13.         while (left < right && a[right] >= a[keyi])
    14.             --right;
    15.  
    16.         // 左边再走，找大
    17.         while (left < right && a[left] <= a[keyi])
    18.             ++left;
    19.  
    20.         Swap(&a[left], &a[right]); // 交换左右指针所指向的元素
    21.     }
    22.     Swap(&a[keyi], &a[left]); // 将基准元素放到正确的位置上
    23.     keyi = left; // 更新基准元素的下标
    24.  
    25.     return keyi; // 返回基准元素的下标
    26. }

    2.2. 挖坑法 相比hoare本质上并没有简化复杂度

    1. int PartSort2(int* a, int begin, int end)
    2. {
    3.     int key = a[begin]; // 选择第一个元素为基准值
    4.     int piti = begin;   // 初始化挖坑位置
    5.  
    6.     while (begin < end)
    7.     {
    8.         // 右边找小，填到左边的坑里面去。这个位置形成新的坑
    9.         while (begin < end && a[end] >= key) // 从右边开始找比基准值小的元素
    10.             --end;
    11.  
    12.         a[piti] = a[end]; // 将小元素填入左边的坑里
    13.         piti = end;       // 更新当前坑的位置
    14.  
    15.         // 左边找大，填到右边的坑里面去。这个位置形成新的坑
    16.         while (begin < end && a[begin] <= key) // 从左边开始找比基准值大的元素
    17.             ++begin;
    18.  
    19.         a[piti] = a[begin]; // 将大元素填入右边的坑里
    20.         piti = begin;       // 更新当前坑的位置
    21.     }
    22.     a[piti] = key; // 将基准值放入最后形成的坑中
    23.     return piti;   // 返回基准值的最终位置

    2.3. 前后指针法

    key非常影响效率：

    1. 当key每次选的都为该数组从小到大的中间值，每次排序为二分，效率更高但当key选的为最 小/大 时为最坏情况 每次递归都是将key后面的数进行递归：N-1+N-2…=O(N^2),且会出现栈溢出
      解决方法：
    • 1.随机选key(但存在巧合)
    • 2.三数取中(头中尾三个数对比选其中一个中间值)
    1. 小区间优化：在每次递归都接近二分基础上(例：有10个数，最后一层要递归13次)减小最后一层递归，当区间较小时就不 在递归去分化去排序这个小区间，可以考虑用其他排序对小区建处理(插入排序)

    2.4三数取中:

    1. // 计算中间索引值
    2. int GetMidIndex(int* a, int begin, int end)
    3. {
    4.     int mid = (begin + end) / 2; // 计算数组中间的索引
    5.     if (a[begin] < a[mid])
    6.     {
    7.         if (a[mid] < a[end]) // 中间值在 begin 和 end 之间
    8.             return mid;
    9.         else if (a[begin] < a[end]) // 中间值在 begin 和 mid 之间
    10.             return end;
    11.         else // 中间值在 end 和 begin 之间
    12.             return begin;
    13.     }
    14.     else // a[begin] > a[mid]
    15.     {
    16.         if (a[mid] > a[end]) // 中间值在 begin 和 end 之间
    17.             return mid;
    18.         else if (a[begin] < a[end]) // 中间值在 begin 和 mid 之间
    19.             return begin;
    20.         else // 中间值在 end 和 begin 之间
    21.             return end;
    22.     }
    23. }
    1. // 前后指针法进行分割
    2. int PartSort3(int* a, int begin, int end)
    3. {
    4.     int prev = begin; // 前指针
    5.     int cur = begin + 1; // 后指针
    6.     int keyi = begin; // 基准值索引
    7.  
    8.     int midi = GetMidIndex(a, begin, end); // 获取中间索引
    9.     Swap(&a[begin], &a[midi]); // 将中间值与第一个元素交换
    10.  
    11.     while (cur <= end)
    12.     {
    13.         // 当后指针位置的值小于基准值时，前指针向前移动一位，并交换前指针和后指针位置的元素
    14.         if (a[cur] < a[keyi] && ++prev != cur)
    15.             Swap(&a[prev], &a[cur]);
    16.         ++cur; // 后指针移动到下一个位置
    17.     }
    18.     Swap(&a[prev], &a[keyi]); // 将基准值放入合适的位置
    19.     keyi = prev; // 更新基准值的索引
    20.  
    21.     return keyi; // 返回基准值的索引
    22. }

    2.5快排主体 &&小区间优化

    头文件中定义：

    1. //直接定义 int callCount=0; 在Sort.和Heap.c 在编译的链接过程中产生冲突,导致输出callCount时会出现错误输出
    2. // static int callCount=0; 为仅该文件可用,错误
    3. //extern : 声明变量
    4. extern int callCount;//快排执行次数
    快排主体 &&小区间优化

    小区间优化：在每次递归都接近二分基础上(例：有10个数，最后一层要递归13次)减小最后一层递归，当区间较小时就不 在递归去分化去排序这个小区间，可以考虑用其他排序对小区建处理(插入排序)

    假设递归深度为h->最后一层的调用次数为2(h-1),倒数第二层为2(h-2)…总调用次数为2h -1
    若区间不再调用最后一层，总调用次数大约会减少50%。(最后一层越50%，倒二层25%，倒三层12.5%)
    假设区间小于10时，不再递归区间->减少80%以上递归次数

    1. void QuickSort(int* a, int begin, int end)
    2. {
    3. 	callCount++;
    4. 	
    5. 	//区间不存在，或者只有一个值则不需要再处理
    6. 	if (begin >= end)
    7. 		return;
    8.  
    9. 	if (end - begin > 10)
    10. 	{
    11. 		//单趟排序
    12. 		int keyi = PartSort3(a, begin, end);
    13.  
    14. 		//区间： [begin,keyi-1] keyi [keyi+1,right]
    15. 		QuickSort(a, begin, keyi - 1);//左区间
    16. 		QuickSort(a, keyi + 1, end);//右区间
    17. 	}
    18. 	else
    19. 	{
    20. 		//小区间优化
    21. 		InsertSort(a + begin, end - begin + 1); //目前QuickSort为左右闭区间故+1
    22. 	}
    23. }

    测试：

    1. void TestQuickSortNonRSort()
    2. {
    3. 	int a[] = { 6,1,2,7,9,3,4,5,10,8 };
    4. 	int sz = sizeof(a) / sizeof(a[0]);
    5.  
    6. 	QuickSortNonR(a, 0, sz - 1);
    7. 	PrintArry(a, sz);
    8. }

    用插入排序优化的具体原因：
    选择插入排序作为小区间优化的方法可以提高性能，并且不会影响整体排序的准确性。当待排序的区间较小时，快速排序使用插入排序进行优化，以获得更好的排序效果和执行效率。

    1. 相对较小的数据规模：当待排序的小区间长度较小时，插入排序的性能通常比快速排序更好。插入排序的时间复杂度为 O(n^2)，但在小规模数据上的操作是高效的。因为插入排序是一种稳定的排序算法，它的元素交换操作相对较少，适用于小规模的数据排序。
    2. 递归调用开销较小：快速排序的核心是递归地对子区间排序，并且递归调用的开销会随着区间大小的增加而增加。对于小区间，递归调用可能会产生不必要的开销。而插入排序是一种原地排序算法，不需要额外的递归调用，因此在小区间上的排序效果更好。
    3. 算法实现的简洁性和可读性：插入排序的实现非常简单，只需要对小区间内的元素进行遍历和比较，然后逐步插入到正确的位置。它的代码逻辑简单清晰，易于理解和维护。

    复杂度（空间/时间）：

    时间复杂度：

    • 最好情况下，当每次选取的基准值都能均匀地将待排序序列划分为相等的两部分时，快速排序的时间复杂度为 O(nlogn)。
    • 最坏情况下，当每次选取的基准值都为当前序列的最小值或最大值时，快速排序的时间复杂度为 O(n^2)。
    • 平均情况下，快速排序的时间复杂度为 O(nlogn)。

    空间复杂度：

    • 快速排序是一种原地排序算法，不需要额外的空间来存储待排序序列，因此空间复杂度为 O(1)。

    • 小区间优化部分使用了插入排序算法来处理较小规模的区间，在该部分中，插入排序的时间复杂度为 O(k^2)，其中 k 表示小规模区间的长度。

    综上所述，该排序算法的时间复杂度为 O(nlogn)，空间复杂度为 O(1)，并通过小区间优化进一步提高了算法在处理小规模区间时的性能

    将快速排序改为非递归

    递归在极端问题下，递归太深,会出现栈溢出
    1.直接该循环–比如斐波那契数列，归并排序
    2.用数据结构栈模拟递归过程

    栈：

    1. //初始化
    2. void StackInit(ST* ps)
    3. {
    4. 	ps->a = (STDataType*)malloc(sizeof(STDataType) * 4);//先创建4个STDataType大小的内存
    5. 	if (ps->a == NULL)
    6. 	{
    7. 		printf("malloc fail!\n");
    8. 		exit(-1);
    9. 	}
    10. 	ps->top = 0;//top初始为0时，top指向的就不是栈尾元素，而是栈尾的下一个元素
    11. 	ps->capacity = 4;//数组的空间大小为4
    12. }
    13.  
    14. //销毁
    15. void StackDestory(ST* ps)
    16. {
    17. 	assert(ps);//判断ps是否为空，如果他为空就说明栈还没有创建，也就不用销毁
    18. 	free(ps->a);//释放数组a的空间
    19. 	ps->a = NULL;//让指针*a 指向空
    20. 	ps->top = ps->capacity = 0;
    21. }
    22.  
    23. //入栈
    24. void StackPush(ST* ps, int x)
    25. {
    26. 	assert(ps);
    27. 	//满了，得增容
    28. 	if (ps->top == ps->capacity)//注意：top从0开始的。并且top指向栈尾元素的下一个地址
    29. 	{
    30. 		STDataType* tmp = (STDataType*)realloc(ps->a, sizeof(STDataType) * ps->capacity * 2);
    31. 		//设置tmp，申请空间成功后，将其赋给ps->a
    32. 		//如果直接用ps->a，申请内存失败后，ps->a就不对劲了
    33. 		if (tmp == NULL)//判断是否申请成功
    34. 		{
    35. 			printf("realloc fail\n");
    36. 			exit(-1);
    37. 		}
    38. 		else
    39. 		{
    40. 			ps->a = tmp;
    41. 			ps->capacity *= 2;//扩大为原来的2倍
    42. 		}
    43. 	}
    44. 	ps->a[ps->top] = x;
    45. 	ps->top++;
    46. }
    47.  
    48. //出栈
    49. void StackPop(ST* ps)
    50. {
    51. 	assert(ps);
    52. 	assert(ps->top > 0);//判断是否栈空
    53. 	ps->top--;
    54. }
    55.  
    56. //取栈顶元素（并不删除栈顶元素）
    57. STDataType StackTop(ST* ps)
    58. {
    59. 	assert(ps);
    60. 	assert(ps->top > 0);//判断是否栈空
    61. 	return ps->a[ps->top - 1];
    62. }
    63.  
    64. //求栈中元素个数
    65. int StackSize(ST* ps)
    66. {
    67. 	assert(ps);
    68. 	return ps->top;
    69. }
    70.  
    71. //判断是否为空
    72. bool StackEmpty(ST* ps)
    73. {
    74. 	assert(ps);
    75. 	return ps->top == 0;
    76. }

    非递归代码实现：

    1. void QuickSortNonR(int* a, int begin, int end)
    2. {
    3. 	ST st;
    4. 	StackInit(&st);
    5. 	//先入左再入右边，出栈时先出右再出左
    6. 	StackPush(&st,end);
    7. 	StackPush(&st,begin);
    8. 	
    9. 	while (!StackEmpty(&st))//无子区间时停止
    10. 	{
    11. 		int left = StackTop(&st);
    12. 		StackPop(&st);
    13. 	
    14. 		int right = StackTop(&st);
    15. 		StackPop(&st);
    16.  
    17. 		int keyi = PartSort3(a, left, right);
    18. 		//[left,keyi-1] keyi [keyi+1,right]
    19.  
    20. 		//左区间类递归
    21. 		if (left-1)
    22. 		{
    23. 			StackPush(&st, keyi-1);
    24. 			StackPush(&st, begin);
    25. 		}
    26.  
    27. 		//右区间类递归
    28. 		if (keyi + 1 < right)
    29. 		{
    30. 			StackPush(&st, right);
    31. 			StackPush(&st, keyi+1);
    32. 		}
    33. 	}
    34. 	StackDestory(&st);
    35. }

    归并排序

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

    1. void _MergeSort(int* a, int begin, int end, int* tmp)//temp:第三方数组
    2. {
    3. 	if (begin >= end)
    4. 		return;
    5.  
    6. 	int mid = (begin + end) / 2;
    7.  
    8. 	// 对左区间进行递归排序
    9. 	_MergeSort(a, begin, mid, tmp);
    10.  
    11. 	// 对右区间进行递归排序
    12. 	_MergeSort(a, mid + 1, end, tmp);
    13.  
    14. 	// 归并左右区间
    15. 	int begin1 = begin, end1 = mid;
    16. 	int begin2 = mid + 1, end2 = end;
    17. 	int i = begin1;
    18.  
    19. 	// 将两个有序区间合并到临时数组 tmp 中
    20. 	while (begin1 <= end1 && begin2 <= end2)
    21. 	{
    22. 		if (a[begin1] < a[begin2])
    23. 		{
    24. 			tmp[i++] = a[begin1++];
    25. 		}
    26. 		else
    27. 		{
    28. 			tmp[i++] = a[begin2++];
    29. 		}
    30. 	}
    31.  
    32. 	// 处理左区间剩余的元素
    33. 	while (begin1 <= end1)
    34. 	{
    35. 		tmp[i++] = a[begin1++];
    36. 	}
    37.  
    38. 	// 处理右区间剩余的元素
    39. 	while (begin2 <= end2)
    40. 	{
    41. 		tmp[i++] = a[begin2++];
    42. 	}
    43.  
    44. 	// 将归并结果拷贝回原数组 a 中
    45. 	memcpy(a + begin, tmp + begin, (end - begin + 1) * sizeof(int));
    46. }
    47.  
    48. // 归并排序
    49. void MergeSort(int* a, int n)
    50. {
    51. 	int* tmp = (int*)malloc(sizeof(int) * n);
    52.  
    53. 	if (tmp == NULL)
    54. 	{
    55. 		printf("malloc fail\n");
    56. 		exit(-1);
    57. 	}
    58.  
    59. 	_MergeSort(a, 0, n - 1, tmp); // 初始调用归并排序
    60.  
    61. 	free(tmp);
    62. }

    归并排序的特性总结：

    1. 归并的缺点在于需要O(N)的空间复杂度，归并排序的思考更多的是解决在磁盘中的外排序问
      题。
    2. 时间复杂度：O(N*logN)
    3. 空间复杂度：O(N)
    4. 稳定性：稳定

    复杂度（空间/时间）：

    时间复杂度：

    • 最好情况下，归并排序的时间复杂度为 O(nlogn)。无论数组的初始顺序如何，归并排序总是将数组对半分割，然后合并，这个过程的时间复杂度是稳定的。
    • 最坏情况下，归并排序的时间复杂度仍然是 O(nlogn)。无论数组的初始顺序如何，归并排序都需要对数组进行完全的分割和合并操作。
    • 平均情况下，归并排序的时间复杂度为 O(nlogn)。归并排序将数组分割为相等大小的子数组，然后对子数组进行合并，因此平均情况下的时间复杂度和最坏情况下相同。

    空间复杂度：

    • 归并排序的空间复杂度为 O(n)。在归并排序的过程中，需要使用一个临时数组来存储归并操作的中间结果。临时数组的长度与待排序数组的长度相同，因此空间复杂度为 O(n)。

    综上所述，这段代码的时间复杂度为 O(nlogn)，空间复杂度为 O(n)。归并排序是一种稳定的、高效的排序算法，适用于各种规模的数据集。

    归并排序非递归实现

    两种实现方法：

    1. 方法一 ：修正边界法
    2. 方法二： 越界只有可能在[begin2,end2] end1，最后一组越界时停止递归而对end1进行修正（建立在方法一基础之上进行更改）

    主体：

    1. void MergeSortNonR(int* a, int n)
    2. {
    3.    _MergeSortNonR2(a, n);//方法一
    4.    _MergeSortNonR2(a, n);//方法二
    5. }

    主函数错误写法：
    改写法没考虑边界问题，会导致越界从而报错


    若选择直接修正begin2即,不进行类递归: 这将导致该数组begin2照样会越界且最后进行memcpy时末尾元素可能会出现随机值

    1. void MergeSortNonR(int* a, int n)
    2. {
    3. 	int* tmp = (int*)malloc(sizeof(int) * n);
    4. 	if (tmp == NULL)
    5. 	{
    6. 		printf("malloc fail\n");
    7. 		exit(-1);
    8. 	}
    9.  
    10. 	int gap = 1;
    11. 	while (gap < n)
    12. 	{
    13. 		printf("gap->%d", gap);
    14. 		for (int i = 0; i < n; i += 2 * gap)
    15. 		{
    16. 			//[imi+gap-1][i+gap,i+2*gap-1] //此时数组长度不为2的次方就会出现越界
    17. 			int begin1 = i, end1 = i + gap - 1;
    18. 			int begin2 = i + gap, end2 = i + 2 * gap - 1;
    19. 			
    20. 			//修正边界(阻止越界)	
    21. 			/*
    22. 				若选择直接修正begin2即,不进行类递归:
    23. 				if (begin2>=2)
    24. 					break;
    25. 				这将导致该数组begin2照样会越界且最后进行memcpy时末尾元素可能会出现随机值
    26. 			*/
    27. 			if (end1 >= n)//end1越界
    28. 			{
    29. 				end1 = n - 1;
    30. 				/*
    31. 					修正end1后，将begin2和end2修正为一个不存在的区间
    32. 					再用if语句进行判断是否越界若是直接退出该次类递归
    33. 				*/
    34. 				//[begin2,end2]
    35. 				begin2 = n;
    36. 				end2 = n - 1;
    37. 			}
    38. 			else if (begin2 >= n)
    39. 			{
    40. 				begin2 = n;
    41. 				end2 = n - 1;
    42. 			}
    43. 			else if (end2 >= n)
    44. 				end2 = n - 1;
    45.  
    46. 			printf("[%d,%d] [%d,%d]--", begin1, end1, begin2, end2);
    47.  
    48. 			int j = begin1;
    49. 			while (begin1 <= end1 && begin2 <= end2)
    50. 			{
    51. 				if (a[begin1] < a[begin2])
    52. 					tmp[j++] = a[begin1++];
    53. 				else
    54. 					tmp[j++] = a[begin2++];
    55. 			}
    56.  
    57. 			while (begin1 <= end1)
    58. 				tmp[j++] = a[begin1++];
    59.  
    60. 			while (begin2 <= end2)
    61. 				tmp[j++] = a[begin2++];
    62. 		}
    63. 		printf("\n");
    64. 		memcpy(a, tmp, n  * sizeof(int));
    65. 		gap *= 2;
    66. 	}
    67. 	free(tmp);
    68. }

    方法一 ：修正边界法

    1. void _MergeSortNonR1(int* a, int n)
    2. {
    3. 	// 分配临时数组 tmp
    4. 	int* tmp = (int*)malloc(sizeof(int) * n);
    5. 	if (tmp == NULL)
    6. 	{
    7. 		printf("malloc fail\n");
    8. 		exit(-1);
    9. 	}
    10.  
    11. 	int gap = 1;
    12.  
    13. 	while (gap < n) // 在 gap 小于数组长度时执行循环
    14. 	{
    15. 		printf("gap->%d", gap);
    16.  
    17. 		for (int i = 0; i < n; i += 2 * gap) // 对数组进行多趟归并
    18. 		{
    19. 			// 获取当前归并的两个子区间的边界
    20. 			int begin1 = i, end1 = i + gap - 1;
    21. 			int begin2 = i + gap, end2 = i + 2 * gap - 1;
    22.  
    23. 			// 修正边界，防止越界
    24. 			if (end1 >= n) // end1 越界，修正为数组最后一个元素的索引
    25. 			{
    26. 				end1 = n - 1;
    27.  
    28. 				// 修正 begin2 和 end2，将它们修正为不存在的区间
    29. 				begin2 = n;
    30. 				end2 = n - 1;
    31. 			}
    32. 			else if (begin2 >= n) // begin2 越界，修正为数组最后一个元素的索引加 1
    33. 			{
    34. 				begin2 = n;
    35. 				end2 = n - 1;
    36. 			}
    37. 			else if (end2 >= n) // end2 越界，修正为数组最后一个元素的索引
    38. 				end2 = n - 1;
    39.  
    40. 			printf("[%d,%d] [%d,%d]--", begin1, end1, begin2, end2);
    41. 			
    42. 			// 将两个有序区间合并到临时数组 tmp 中
    43. 			int j = begin1;
    44. 			while (begin1 <= end1 && begin2 <= end2)
    45. 			{
    46. 				if (a[begin1] < a[begin2])
    47. 					tmp[j++] = a[begin1++];
    48. 				else
    49. 					tmp[j++] = a[begin2++];
    50. 			}
    51.  
    52. 			// 处理左区间剩余的元素
    53. 			while (begin1 <= end1)
    54. 				tmp[j++] = a[begin1++];
    55.  
    56. 			// 处理右区间剩余的元素
    57. 			while (begin2 <= end2)
    58. 				tmp[j++] = a[begin2++];
    59. 		}
    60. 		printf("\n");
    61.  
    62. 		// 将归并结果拷贝回原数组 a
    63. 		memcpy(a, tmp, n * sizeof(int));
    64.  
    65. 		// 调整 gap 的大小，以进行下一轮归并操作
    66. 		gap *= 2;
    67. 	}
    68. 	
    69. 	free(tmp); // 释放临时数组的内存空间
    70. }

    方法二 ：

    越界只有可能在[begin2,end2] end1，最后一组越界时停止递归而对end1进行修正

    1. void _MergeSortNonR2(int* a, int n)
    2. {
    3. 	int* tmp = (int*)malloc(sizeof(int) * n);
    4. 	if (tmp == NULL)
    5. 	{
    6. 		printf("malloc fail\n");
    7. 		exit(-1);
    8. 	}
    9.  
    10. 	int gap = 1;
    11.  
    12. 	while (gap < n) // 在 gap 小于数组长度时执行循环
    13. 	{
    14. 		printf("gap->%d ", gap);
    15.  
    16. 		for (int i = 0; i < n; i += 2 * gap) // 对数组进行多趟归并
    17. 		{
    18. 			// 获取当前归并的两个子区间的边界
    19. 			int begin1 = i, end1 = i + gap - 1;
    20. 			int begin2 = i + gap, end2 = i + 2 * gap - 1;
    21.  
    22. 			// 如果 end1 越界或 begin2 越界，则可以不执行归并操作了
    23. 			if (end1 >= n || begin2 >= n)
    24. 				break;
    25. 			else if (end2 >= n)
    26. 				end2 = n - 1;
    27.  
    28. 			//printf("[%d,%d] [%d,%d]--", begin1, end1, begin2, end2);
    29.  
    30. 			int m = end2 - begin1 + 1; // 计算归并元素的个数
    31. 			int j = begin1;
    32.  
    33. 			// 将两个有序子区间合并到临时数组 tmp 中
    34. 			while (begin1 <= end1 && begin2 <= end2)
    35. 			{
    36. 				if (a[begin1] < a[begin2])
    37. 					tmp[j++] = a[begin1++];
    38. 				else
    39. 					tmp[j++] = a[begin2++];
    40. 			}
    41.  
    42. 			// 处理左区间剩余的元素
    43. 			while (begin1 <= end1)
    44. 				tmp[j++] = a[begin1++];
    45.  
    46. 			// 处理右区间剩余的元素
    47. 			while (begin2 <= end2)
    48. 				tmp[j++] = a[begin2++];
    49.  
    50. 			// 将归并结果从临时数组 tmp 拷贝回原数组 a
    51. 			memcpy(a + i, tmp + i, sizeof(int) * m);
    52. 		}
    53.  
    54. 		// 调整 gap 的大小，将其扩大两倍，以进行下一轮归并操作
    55. 		gap *= 2;
    56. 	}
    57.  
    58. 	free(tmp); // 释放临时数组的内存空间
    59. }

    测试：

    1. void TestMergeSortNonR()
    2. {
    3. 	int a[] = { 6,1,2,7,9,3,4,5,10,8 };
    4. 	int sz = sizeof(a) / sizeof(a[0]);
    5.  
    6. 	MergeSortNonR(a, sz);
    7. 	PrintArry(a, sz);
    8. }

     

    全部功能测试

    test.c:
    调试时最好切换为Release版本，否则可能导致计算效率不是很准确

    1. void TestOP()
    2. {
    3. 	srand(time(0));
    4. 	const int N = 10000;//可自行更改，但部分排序算法效率太低可能运行时间会很久
    5. 	int* a1 = (int*)malloc(sizeof(int) * N);
    6. 	int* a2 = (int*)malloc(sizeof(int) * N);
    7. 	int* a3 = (int*)malloc(sizeof(int) * N);
    8. 	int* a4 = (int*)malloc(sizeof(int) * N);
    9. 	int* a5 = (int*)malloc(sizeof(int) * N);
    10. 	int* a6 = (int*)malloc(sizeof(int) * N);
    11. 	int* a7 = (int*)malloc(sizeof(int) * N);
    12. 	for (int i = 0; i < N; ++i)
    13. 	{
    14. 		a1[i] = rand();
    15. 		a2[i] = a1[i];
    16. 		a3[i] = a1[i];
    17. 		a4[i] = a1[i];
    18. 		a5[i] = a1[i];
    19. 		a6[i] = a1[i];
    20. 	}
    21. 	int begin1 = clock();
    22. 	InsertSort(a1, N);
    23. 	int end1 = clock();
    24.  
    25. 	int begin2 = clock();
    26. 	ShellSort(a2, N);
    27. 	int end2 = clock();
    28.  
    29. 	int begin3 = clock();
    30. 	SelectSort(a3, N);
    31. 	int end3 = clock();
    32.  
    33. 	int begin4 = clock();
    34. 	HeapSort(a4, N);
    35. 	int end4 = clock();
    36.  
    37. 	int begin5 = clock();
    38. 	QuickSort(a5, 0, N - 1);
    39. 	int end5 = clock();
    40.  
    41. 	int begin6 = clock();
    42. 	MergeSort(a6, N);
    43. 	int end6 = clock();
    44.  
    45. 	int begin7 = clock();
    46. 	//Bubblesort(a7, N);
    47. 	int end7 = clock();
    48.  
    49. 	printf("直接插入排序InsertSort:%d\n", end1 - begin1);
    50. 	printf("希尔排序ShellSort:%d\n", end2 - begin2);
    51. 	printf("选择排序SelectSort:%d\n", end3 - begin3);
    52. 	printf("堆排序HeapSort:%d\n", end4 - begin4);
    53. 	//printf("冒泡排序Bubblesort:%d\n", end7 - begin7);
    54. 	printf("快速排序QuickSort:%d\n", end5 - begin5);
    55. 	printf("归并排序MergeSort:%d\n", end6 - begin6);
    56.  
    57. 	printf("callCount:%d\n", callCount);
    58. 	printf("%p\n", &callCount);
    59. 	free(a1);
    60. 	free(a2);
    61. 	free(a3);
    62. 	free(a4);
    63. 	free(a5);
    64. 	free(a6);
    65. 	//free(a7);
    66. }
    67.  
    68. int main()
    69. {
    70. 	TestOP();
    71. }

    全部代码

    将展现书写本文的所有代码以供参考

    头文件

    1.Sort.h
    1. #pragma once
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7.  
    8. void PrintArry(int* a, int n);
    9.  
    10. //直接插入排序
    11. void InsertSort(int* a, int n);
    12.  
    13. //希尔排序
    14. void ShellSort(int* a, int n);
    15.  
    16. //选择排序
    17. void SelectSort(int* a, int n);
    18.  
    19. void Swap(int* p1, int* p2);
    20.  
    21. void AdjustDown(int* a, int size, int parent);
    22.  
    23. //堆排序
    24. void HeapSort(int* a, int n);
    25.  
    26. //冒泡排序
    27. void Bubblesort(int* a, int n);
    28.  
    29. //快速排序
    30. void QuickSort(int* a, int begin, int end);
    31. //直接定义 int callCount=0; 在Sort.和Heap.c 在编译的链接过程中产生冲突,导致输出callCount时会出现错误输出
    32. // static int callCount=0; 为仅该文件可用,错误
    33. //extern : 声明变量
    34. extern int callCount;//快排执行次数
    35.  
    36. //将快速排序改为非递归
    37. void QuickSortNonR(int* a, int begin, int end);
    38.  
    39. //归并排序
    40. void MergeSort(int* a, int n);
    41.  
    42. //非递归 归并排序
    43. void MergeSortNonR(int* a, int n);
    2.Stack.h
    1. #pragma once
    2. #include
    3. #include
    4. #include
    5. #include
    6.  
    7. typedef int STDataType;
    8. typedef struct Stack
    9. {
    10. 	STDataType* a;
    11. 	int top;
    12. 	int capacity;
    13. }ST;
    14.  
    15.  
    16. //初始化
    17. void StackInit(ST* ps);
    18.  
    19. //销毁
    20. void StackDestory(ST* ps);
    21.  
    22. //入栈
    23. void StackPush(ST* ps, int x);
    24.  
    25. //出栈
    26. void StackPop(ST* ps);
    27.  
    28. //取栈顶元素（并不删除栈顶元素）
    29. STDataType StackTop(ST* ps);
    30.  
    31. //求栈中元素个数
    32. int StackSize(ST* ps);
    33.  
    34. //判断是否为空
    35. bool StackEmpty(ST* ps);

    函数实现文件

    1.Sort.c
    1. #include "Sort.h"
    2. #include "Stack.h"
    3.  
    4. void PrintArry(int* a, int n)
    5. {
    6. 	for (int i = 0; i < n; i++)
    7. 		printf("%d ",a[i]);
    8.  
    9. 	printf("\n");
    10. }
    11.  
    12. //直接插入排序
    13. //1，直接插入排序（单趟排序） 一个数一次向后比较一个元素，当比该数字小时，后面元素后移，后插入该数
    14. void InsertSort(int* a, int n)
    15. {
    16. 	for (int i = 0; i < n - 1; i++)
    17. 	{
    18. 		// [0,end]有序，吧end+1 位置的值插入，保持有序
    19. 		int end = i;
    20. 		int tmp = a[end + 1];
    21. 		while (end >= 0)
    22. 		{
    23. 			if (tmp < a[end])//要交换的数字更大
    24. 			{
    25. 				//指针指向元素后移，end指针前移
    26. 				a[end + 1] = a[end];
    27. 				--end;
    28. 			}
    29. 			else
    30. 			{
    31. 				//要交换的数字更小,退出循环
    32. 				break;
    33. 			}
    34. 		}
    35. 		//开始交换
    36. 		a[end + 1] = tmp;
    37. 	}
    38. }
    39.  
    40. //希尔排序
    41. /*
    42. 	1,预排序(接近顺序有序)
    43. 	2,直接插入排序(有序)
    44. */
    45. //void ShellSort(int* a, int n)
    46. //{
    47. //	int gap = 3;
    48. //	//gap组交替进行排序
    49. //	/*
    50. //	gap越大大的数更快到后面,小的数可以更快到前面
    51. //	排升序,gap越小,越接近有序,当gap==1,就是插入排序
    52. //	*/
    53. //	for (int i = 0; i < n-gap; i++)
    54. //	{
    55. //		int end = i;
    56. //		int tmp = a[end + gap];
    57. //
    58. //		while (end >= 0)
    59. //		{
    60. //			if (tmp < a[end])
    61. //			{
    62. //				//排序
    63. //				a[end + gap] = a[end];
    64. //				end -= gap;
    65. //			}
    66. //			else
    67. //				break;
    68. //		}
    69. //		a[end + gap] = tmp;
    70. //	}
    71. 	//for (int j = 0; j < gap; j++)//往前走一位,gap另一部分
    72. 	//{
    73. 	//	for (int i = 0; i < n - gap; i += gap)
    74. 	//	{
    75. 	//		int end = i;
    76. 	//		int tmp = a[end + gap];
    77.  
    78. 	//		while (end >= 0)
    79. 	//		{
    80. 	//			if (tmp < a[end])
    81. 	//			{
    82. 	//				//排序
    83. 	//				a[end + gap] = a[end];
    84. 	//				end -= gap;
    85. 	//			}
    86. 	//			else
    87. 	//				break;
    88. 	//		}
    89. 	//		a[end + gap] = tmp;
    90. 	//	}
    91. 	//}
    92. //}
    93.  
    94. void Swap(int* p1, int* p2)
    95. {
    96. 	int tmp = *p1;
    97. 	*p1 = *p2;
    98. 	*p2 = tmp;
    99. }
    100.  
    101. void ShellSort(int* a, int n)
    102. {
    103. 	int gap = n;
    104. 	while (gap > 1)
    105. 	{
    106. 		gap = gap / 3 + 1;// /3:保证每次跳跃的间隔. 1：保证不为0
    107.  
    108. 		//gap组交替进行排序
    109. 		/*
    110. 		gap越大大的数更快到后面,小的数可以更快到前面
    111. 		排升序,gap越小,越接近有序,当gap==1,就是插入排序
    112. 		*/
    113. 		for (int i = 0; i < n - gap; i++)//往前走一位,gap另一部分	
    114. 		{
    115. 			int end = i;
    116. 			int tmp = a[end + gap];
    117.  
    118. 			while (end >= 0)
    119. 			{
    120. 				if (tmp < a[end])
    121. 				{
    122. 					//排序
    123. 					a[end + gap] = a[end];
    124. 					end -= gap;
    125. 				}
    126. 				else
    127. 					break;
    128. 			}
    129. 			a[end + gap] = tmp;
    130. 		}
    131. 	}
    132. }
    133.  
    134.  
    135. //选择排序 o(N^2)
    136. //对比插入排序，还是插入排序更优
    137. void SelectSort(int* a, int n)
    138. {
    139. 	assert(a);
    140. 	//遍历一遍选出最小and最大的，分别放在左右边
    141. 	int begin = 0, end = n - 1;
    142. 	int mini = begin, maxi = begin;
    143. 	while (begin
    144. 	{
    145. 		for (int i = 0; i <= end; i++)
    146. 		{
    147. 			if (a[i] < a[mini])
    148. 				mini = i;
    149.  
    150. 			if (a[i] > a[maxi])
    151. 				maxi = i;
    152. 		}
    153.  
    154. 		Swap(&a[begin], &a[mini]);
    155.  
    156. 		//如果begin和maxi重叠，那么需要修正位置
    157. 		if (begin == maxi)
    158. 			maxi = mini;
    159.  
    160. 		Swap(&a[end], &a[maxi]);
    161. 		++begin;
    162. 		--end;
    163. 	}
    164. } 
    165.  
    166. //冒泡排序  时间复杂度O(N^2),最坏情况还为O(N^2)
    167. //对比插入排序哪个更好？--接近有序或局部有序时，插入排序能更好适应
    168. void Bubblesort(int* a, int n)
    169. {
    170. 	assert(a);
    171.  
    172. 	for (int j = 0; j < n; j++)
    173. 	{
    174. 		int exchange = 0;
    175. 		for (int i = 0; i < n - j; i++)
    176. 		{
    177. 			if (a[i - 1] > a[i])
    178. 			{
    179. 				Swap(&a[i - 1], &a[i]);
    180. 				exchange = 1;
    181. 			}
    182. 		}
    183. 		if (exchange == 0)
    184. 			break;
    185. 	}
    186. }
    187.  
    188. void _MergeSort(int* a, int begin, int end,int* tmp)//temp:第三方数组
    189. {
    190. 	if (begin >= end)
    191. 		return;
    192.  
    193. 	int mid=(begin + end) / 2;
    194. 	//[begin,mid][mid+1,end]分值递归，让子区间有序
    195. 	
    196. 	_MergeSort(a, begin, mid, tmp);	// 递归  左区间
    197. 	_MergeSort(a, mid + 1, end, tmp);//递归 右边区间
    198.  
    199. 	//归并[begin,mid][mid+1,end]
    200. 	int begin1 = begin, end1 = mid;
    201. 	int begin2 = mid + 1, end2 = end;
    202. 	int i = begin1;
    203. 	while (begin1<=end1 && begin2<=end2)
    204. 	{
    205. 		if (a[begin1]< a[begin2])
    206. 		{
    207. 			tmp[i++] = a[begin1++];
    208. 		}
    209. 		else
    210. 		{
    211. 			tmp[i++] = a[begin2++];
    212. 		}
    213. 	}
    214. 	
    215. 	while (begin1<=end1)
    216. 	{
    217. 		tmp[i++] = a[begin1++];
    218. 	}
    219. 	
    220. 	while (begin2 <= end2)
    221. 	{
    222. 		tmp[i++] = a[begin2++];
    223. 	}
    224.  
    225. 	//把归并拷贝回原数组
    226. 	memcpy(a + begin, tmp + begin, (end - begin + 1) * sizeof(int));
    227. }
    228.  
    229. //归并排序
    230. void MergeSort(int* a, int n)
    231. {
    232. 	int* tmp = (int*)malloc(sizeof(int) * n);
    233. 	if (tmp == NULL)
    234. 	{
    235. 		printf("malloc fail\n");
    236. 		exit(-1);
    237. 	}
    238. 	_MergeSort(a, 0, n - 1, tmp);
    239.  
    240. 	free(tmp);
    241. }
    242.  
    243. 非递归 归并排序
    244. //void MergeSortNonR(int* a, int n)
    245. //{
    246. //	int* tmp = (int*)malloc(sizeof(int) * n);
    247. //	if (tmp == NULL)
    248. //	{
    249. //		printf("malloc fail\n");
    250. //		exit(-1);
    251. //	}
    252. //	int gap = 1;
    253. //	while (gap
    254. //	{
    255. //		printf("gap->%d",gap);
    256. //		for (int i = 0; i < n; i += 2 * gap)
    257. //		{ 
    258. //			//[imi+gap-1][i+gap,i+2*gap-1] //此时数组长度不为2的次方就会出现越界
    259. //			int begin1 = i, end1 = i + gap - 1;
    260. //			int begin2 = i + gap, end2 = i + 2 * gap - 1;
    261. //			printf("[%d,%d] [%d,%d]--", begin1, end1, begin2, end2);
    262. //
    263. //			int j = begin1;
    264. //			while (begin1 <= end1 && begin2 <= end2)
    265. //			{
    266. //				if (a[begin1] < a[begin2])
    267. //				{
    268. //					tmp[j++] = a[begin1++];
    269. //				}
    270. //				else
    271. //				{
    272. //					tmp[j++] = a[begin2++];
    273. //				}
    274. //			}
    275. //			while (begin1 <= end1)
    276. //			{
    277. //				tmp[j++] = a[begin1++];
    278. //
    279. //			}
    280. //
    281. //			while (begin2 <= end2)
    282. //			{
    283. //				tmp[j++] = a[begin2++];
    284. //			}
    285. //		}
    286. //		printf("\n");
    287. //		memcpy(a, tmp, n * sizeof(int));
    288. //		gap *= 2;
    289. //	}
    290. //	free(tmp);
    291. //}
    292. //非递归 归并排序
    293. /* 
    294. 	end1 begin2 end2 皆有可能出现越界
    295. 	故应该修正边界 
    296. */
    297.  
    298. //方法一 修正边界法
    299. void _MergeSortNonR1(int* a, int n)
    300. {
    301. 	int* tmp = (int*)malloc(sizeof(int) * n);
    302. 	if (tmp == NULL)
    303. 	{
    304. 		printf("malloc fail\n");
    305. 		exit(-1);
    306. 	}
    307.  
    308. 	int gap = 1;
    309. 	while (gap < n)
    310. 	{
    311. 		printf("gap->%d", gap);
    312. 		for (int i = 0; i < n; i += 2 * gap)
    313. 		{
    314. 			//[imi+gap-1][i+gap,i+2*gap-1] //此时数组长度不为2的次方就会出现越界
    315. 			int begin1 = i, end1 = i + gap - 1;
    316. 			int begin2 = i + gap, end2 = i + 2 * gap - 1;
    317.  
    318. 			//修正边界(阻止越界)	
    319. 			/*
    320. 				若选择直接修正begin2即,不进行类递归:
    321. 				if (begin2>=2)
    322. 					break;
    323. 				这将导致该数组begin2照样会越界且最后进行memcpy时末尾元素可能会出现随机值
    324. 			*/
    325. 			if (end1 >= n)//end1越界
    326. 			{
    327. 				end1 = n - 1;
    328. 				/*
    329. 					修正end1后，将begin2和end2修正为一个不存在的区间
    330. 					再用if语句进行判断是否越界若是直接退出该次类递归
    331. 				*/
    332. 				//[begin2,end2]
    333. 				begin2 = n;
    334. 				end2 = n - 1;
    335. 			}
    336. 			else if (begin2 >= n)
    337. 			{
    338. 				begin2 = n;
    339. 				end2 = n - 1;
    340. 			}
    341. 			else if (end2 >= n)
    342. 				end2 = n - 1;
    343.  
    344. 			printf("[%d,%d] [%d,%d]--", begin1, end1, begin2, end2);
    345.  
    346. 			int j = begin1;
    347. 			while (begin1 <= end1 && begin2 <= end2)
    348. 			{
    349. 				if (a[begin1] < a[begin2])
    350. 					tmp[j++] = a[begin1++];
    351. 				else
    352. 					tmp[j++] = a[begin2++];
    353. 			}
    354.  
    355. 			while (begin1 <= end1)
    356. 				tmp[j++] = a[begin1++];
    357.  
    358. 			while (begin2 <= end2)
    359. 				tmp[j++] = a[begin2++];
    360. 		}
    361. 		printf("\n");
    362. 		memcpy(a, tmp, n * sizeof(int));
    363. 		gap *= 2;
    364. 	}
    365. 	free(tmp);
    366. }
    367.  
    368. //方法二 越界只有可能在[begin2,end2] end1，最后一组越界时停止递归而对end1进行修正
    369. void _MergeSortNonR2(int* a, int n)
    370. {
    371. 	int* tmp = (int*)malloc(sizeof(int) * n);
    372. 	if (tmp == NULL)
    373. 	{
    374. 		printf("malloc fail\n");
    375. 		exit(-1);
    376. 	}
    377.  
    378. 	int gap = 1;
    379. 	while (gap < n)
    380. 	{
    381. 		printf("gap->%d ", gap);
    382. 		for (int i = 0; i < n; i += 2 * gap)
    383. 		{
    384. 			//[imi+gap-1][i+gap,i+2*gap-1] //此时数组长度不为2的次方就会出现越界
    385. 			int begin1 = i, end1 = i + gap - 1;
    386. 			int begin2 = i + gap, end2 = i + 2 * gap - 1;
    387.  
    388. 			//end1越界或begin2越界。则可以不归并了
    389. 			if (end1 >= n || begin2 >= n)
    390. 				break;
    391. 			else if (end2 >= n)
    392. 				end2 = n - 1;
    393.  
    394. 			//printf("[%d,%d] [%d,%d]--", begin1, end1, begin2, end2);
    395. 			
    396. 			int m = end2 - begin1+1;//元素个数
    397. 			int j = begin1;
    398. 			while (begin1 <= end1 && begin2 <= end2)
    399. 			{
    400. 				if (a[begin1] < a[begin2])
    401. 					tmp[j++] = a[begin1++];
    402. 				else
    403. 					tmp[j++] = a[begin2++];
    404. 			}
    405.  
    406. 			while (begin1 <= end1)
    407. 				tmp[j++] = a[begin1++];
    408.  
    409. 			while (begin2 <= end2)
    410. 				tmp[j++] = a[begin2++];
    411.  
    412. 			//每类递归依次，进行一次拷贝 
    413. 			memcpy(a + i, tmp + i, sizeof(int) * m);
    414. 		}
    415. 		gap *= 2;
    416. 	}
    417. 	free(tmp);
    418. }
    419.  
    420. void MergeSortNonR(int* a, int n)
    421. {
    422. 	_MergeSortNonR2(a, n);
    423. }
    424.  
    425. //void MergeSortNonR(int* a, int n)
    426. //{
    427. //	int* tmp = (int*)malloc(sizeof(int) * n);
    428. //	if (tmp == NULL)
    429. //	{
    430. //		printf("malloc fail\n");
    431. //		exit(-1);
    432. //	}
    433. //
    434. //	int gap = 1;
    435. //	while (gap < n)
    436. //	{
    437. //		printf("gap->%d", gap);
    438. //		for (int i = 0; i < n; i += 2 * gap)
    439. //		{
    440. //			//[imi+gap-1][i+gap,i+2*gap-1] //此时数组长度不为2的次方就会出现越界
    441. //			int begin1 = i, end1 = i + gap - 1;
    442. //			int begin2 = i + gap, end2 = i + 2 * gap - 1;
    443. //			
    444. //			//修正边界(阻止越界)	
    445. //			/*
    446. //				若选择直接修正begin2即,不进行类递归:
    447. //				if (begin2>=2)
    448. //					break;
    449. //				这将导致该数组begin2照样会越界且最后进行memcpy时末尾元素可能会出现随机值
    450. //			*/
    451. //			if (end1 >= n)//end1越界
    452. //			{
    453. //				end1 = n - 1;
    454. //				/*
    455. //					修正end1后，将begin2和end2修正为一个不存在的区间
    456. //					再用if语句进行判断是否越界若是直接退出该次类递归
    457. //				*/
    458. //				//[begin2,end2]
    459. //				begin2 = n;
    460. //				end2 = n - 1;
    461. //			}
    462. //			else if (begin2 >= n)
    463. //			{
    464. //				begin2 = n;
    465. //				end2 = n - 1;
    466. //			}
    467. //			else if (end2 >= n)
    468. //				end2 = n - 1;
    469. //
    470. //			printf("[%d,%d] [%d,%d]--", begin1, end1, begin2, end2);
    471. //
    472. //			int j = begin1;
    473. //			while (begin1 <= end1 && begin2 <= end2)
    474. //			{
    475. //				if (a[begin1] < a[begin2])
    476. //					tmp[j++] = a[begin1++];
    477. //				else
    478. //					tmp[j++] = a[begin2++];
    479. //			}
    480. //
    481. //			while (begin1 <= end1)
    482. //				tmp[j++] = a[begin1++];
    483. //
    484. //			while (begin2 <= end2)
    485. //				tmp[j++] = a[begin2++];
    486. //		}
    487. //		printf("\n");
    488. //		memcpy(a, tmp, n  * sizeof(int));
    489. //		gap *= 2;
    490. //	}
    491. //	free(tmp);
    492. //}
    2.QuickSort.c
    1. #include "Sort.h"
    2. #include "Stack.h"
    3.  
    4. //调试时最好切换为Release版本
    5.  
    6. //快速排序
    7.  
    8. //进行声明并初始化 ，此时当前文件callCount 与Sort.h中的为同一变量
    9. int callCount = 0;
    10.  
    11. //1，hoare版本
    12. int PartSort1(int* a, int begin, int end)
    13. {
    14. 	//区间不存在，或者只有一个值则不需要再处理
    15. 	if (begin >= end)
    16. 		return;
    17.  
    18. 	int left = begin, right = end;
    19. 	int keyi = left;
    20.  
    21. 	while (left < right)
    22. 	{
    23. 		//右边先走，找小
    24. 		while (left < right && a[right] >= a[keyi])
    25. 			--right;
    26.  
    27. 		// 左边再走，找大
    28. 		while (left < right && a[left] <= a[keyi])
    29. 			++left;
    30.  
    31. 		Swap(&a[left], &a[right]);
    32. 	}
    33. 	Swap(&a[keyi], &a[left]);
    34. 	keyi = left;
    35.  
    36. 	return keyi;
    37. }
    38.  
    39. //2,挖坑法 相比hoare本质上并没有简化复杂度
    40. int PartSort2(int* a, int begin, int end)
    41. {
    42.     int key = a[begin]; // 选择第一个元素为基准值
    43.     int piti = begin;   // 初始化挖坑位置
    44.  
    45.     while (begin < end)
    46.     {
    47.         // 右边找小，填到左边的坑里面去。这个位置形成新的坑
    48.         while (begin < end && a[end] >= key) // 从右边开始找比基准值小的元素
    49.             --end;
    50.  
    51.         a[piti] = a[end]; // 将小元素填入左边的坑里
    52.         piti = end;       // 更新当前坑的位置
    53.  
    54.         // 左边找大，填到右边的坑里面去。这个位置形成新的坑
    55.         while (begin < end && a[begin] <= key) // 从左边开始找比基准值大的元素
    56.             ++begin;
    57.  
    58.         a[piti] = a[begin]; // 将大元素填入右边的坑里
    59.         piti = begin;       // 更新当前坑的位置
    60.     }
    61.     a[piti] = key; // 将基准值放入最后形成的坑中
    62.     return piti;   // 返回基准值的最终位置
    63. }
    64.  
    65. //计算中间值
    66. int GetMidIndex(int* a, int begin, int end)
    67. {
    68. 	int mid = (begin + end) / 2;
    69. 	if (a[begin] < a[mid])
    70. 	{
    71. 		if (a[mid] < a[end])
    72. 			return mid;
    73. 		else if (a[begin] < a[end])
    74. 			return end;
    75. 		else
    76. 			return begin;
    77. 	}
    78. 	else //a[begin]>a[mid]
    79. 	{
    80. 		if (a[mid] > a[end])
    81. 			return mid;
    82. 		else if (a[begin] < a[end])
    83. 			return begin;
    84. 		else
    85. 			return end;
    86. 	}
    87. }
    88.  
    89. //前后指针法
    90. int PartSort3(int* a, int begin, int end)
    91. {
    92. 	int prev = begin;
    93. 	int cur = begin + 1;
    94. 	int keyi = begin;
    95. 	
    96. 	int midi = GetMidIndex(a, begin, end);
    97. 	Swap(&a[begin], &a[midi]);
    98.  
    99. 	while (cur<=end)
    100. 	{
    101. 		//cur位置的值小于keyi位置的值
    102. 		if (a[cur] < a[keyi] && ++prev != cur)
    103. 			Swap(&a[prev], &a[cur]);
    104. 		++cur;
    105. 	}
    106. 	Swap(&a[prev], &a[keyi]);
    107. 	keyi = prev;
    108.  
    109. 	return keyi;
    110. }
    111. /*
    112. 	key非常影响效率：
    113. 	1.当key每次选的都为该数组从小到大的中间值，每次排序为二分，效率更高
    114. 	  但当key选的为最 小/大 时为最坏情况 
    115. 	  每次递归都是将key后面的数进行递归：N-1+N-2...=O(N^2),且会出现栈溢出
    116. 	  解决方法：1.随机选key(但存在巧合)2，三数取中(头中尾三个数对比选其中一个中间值)
    117. 	2.小区间优化：在每次递归都接近二分基础上(例：有10个数，最后一层要递归13次)
    118. 	  减小最后一层递归，当区间较小时就不在递归去分化去排序这个小区间，
    119. 	  可以考虑用其他排序对小区建处理(插入排序)
    120. 	假设递归深度为h->最后一层的调用次数为2^(h-1),倒数第二层为2^(h-2)...总调用次数为2^h - 1
    121. 	若区间不再调用最后一层，总调用次数大约会减少50%。(最后一层越50%，倒二层25%，倒三层12.5%)
    122. 	假设区间小于10时，不再递归区间->减少80%以上递归次数
    123. */
    124.  
    125. void QuickSort(int* a, int begin, int end)
    126. {
    127. 	callCount++;
    128. 	
    129. 	//区间不存在，或者只有一个值则不需要再处理
    130. 	if (begin >= end)
    131. 		return;
    132.  
    133. 	if (end - begin > 10)
    134. 	{
    135. 		//单趟排序
    136. 		int keyi = PartSort3(a, begin, end);
    137.  
    138. 		//区间： [begin,keyi-1] keyi [keyi+1,right]
    139. 		QuickSort(a, begin, keyi - 1);
    140. 		QuickSort(a, keyi + 1, end);
    141. 	}
    142. 	else
    143. 	{
    144. 		//小区间优化
    145. 		InsertSort(a + begin, end - begin + 1); //目前QuickSort为左右闭区间故+1
    146. 	}
    147. }
    148.  
    149. //将快速排序改为非递归 ->递归在极端问题下，递归太深,会出现栈溢出
    150. //1.直接该循环--比如斐波那契数列，归并排序	
    151. //2.用数据结构栈模拟递归过程
    152. void QuickSortNonR(int* a, int begin, int end)
    153. {
    154. 	ST st;
    155. 	StackInit(&st);
    156. 	//先入左再入右边，出栈时先出右再出左
    157. 	StackPush(&st,end);
    158. 	StackPush(&st,begin);
    159. 	
    160. 	while (!StackEmpty(&st))//无子区间时停止
    161. 	{
    162. 		int left = StackTop(&st);
    163. 		StackPop(&st);
    164. 	
    165. 		int right = StackTop(&st);
    166. 		StackPop(&st);
    167.  
    168. 		int keyi = PartSort3(a, left, right);
    169. 		//[left,keyi-1] keyi [keyi+1,right]
    170.  
    171. 		//左区间类递归
    172. 		if (left-1)
    173. 		{
    174. 			StackPush(&st, keyi-1);
    175. 			StackPush(&st, begin);
    176. 		}
    177.  
    178. 		//右区间类递归
    179. 		if (keyi + 1 < right)
    180. 		{
    181. 			StackPush(&st, right);
    182. 			StackPush(&st, keyi+1);
    183. 		}
    184. 	}
    185. 	StackDestory(&st);
    186. }
    3.Heap.c
    1. #include "Sort.h"
    2.  
    3. //向下调整
    4. void AdjustDown(int* a, int size, int parent)
    5. {
    6. 	int child = parent * 2 + 1;
    7. 	while (child < size)
    8. 	{
    9. 		if (child + 1 < size && a[child + 1] > a[child])
    10. 			++child;
    11.  
    12. 		//跟孩子父亲比较
    13. 		if (a[child] > a[parent])
    14. 		{
    15. 			Swap(&a[child], &a[parent]);
    16. 			parent = child;
    17. 			child = parent * 2 + 1;
    18. 		}
    19. 		else
    20. 		{
    21. 			//左右孩子都大于/小于父亲，结束交换
    22. 			break;
    23. 		}
    24. 	}
    25. }
    26.  
    27. //堆排序
    28. void HeapSort(int* a, int n)
    29. {
    30. 	//时间复杂度：O(N)
    31. 	for (int i = (n - 1) / 2; i >= 0; i--)
    32. 		AdjustDown(a, n, i);
    33.  
    34. 	int end = n - 1;
    35. 	while (end > 0)
    36. 	{
    37. 		Swap(&a[0], &a[end]);
    38. 		AdjustDown(a, end, 0);
    39. 		--end;
    40. 	}
    41. }
    42.
    4.Stack.c
    1. #include "Stack.h"
    2.  
    3. //初始化
    4. void StackInit(ST* ps)
    5. {
    6. 	ps->a = (STDataType*)malloc(sizeof(STDataType) * 4);//先创建4个STDataType大小的内存
    7. 	if (ps->a == NULL)
    8. 	{
    9. 		printf("malloc fail!\n");
    10. 		exit(-1);
    11. 	}
    12. 	ps->top = 0;//top初始为0时，top指向的就不是栈尾元素，而是栈尾的下一个元素
    13. 	ps->capacity = 4;//数组的空间大小为4
    14. }
    15.  
    16. //销毁
    17. void StackDestory(ST* ps)
    18. {
    19. 	assert(ps);//判断ps是否为空，如果他为空就说明栈还没有创建，也就不用销毁
    20. 	free(ps->a);//释放数组a的空间
    21. 	ps->a = NULL;//让指针*a 指向空
    22. 	ps->top = ps->capacity = 0;
    23. }
    24.  
    25. //入栈
    26. void StackPush(ST* ps, int x)
    27. {
    28. 	assert(ps);
    29. 	//满了，得增容
    30. 	if (ps->top == ps->capacity)//注意：top从0开始的。并且top指向栈尾元素的下一个地址
    31. 	{
    32. 		STDataType* tmp = (STDataType*)realloc(ps->a, sizeof(STDataType) * ps->capacity * 2);
    33. 		//设置tmp，申请空间成功后，将其赋给ps->a
    34. 		//如果直接用ps->a，申请内存失败后，ps->a就不对劲了
    35. 		if (tmp == NULL)//判断是否申请成功
    36. 		{
    37. 			printf("realloc fail\n");
    38. 			exit(-1);
    39. 		}
    40. 		else
    41. 		{
    42. 			ps->a = tmp;
    43. 			ps->capacity *= 2;//扩大为原来的2倍
    44. 		}
    45. 	}
    46. 	ps->a[ps->top] = x;
    47. 	ps->top++;
    48. }
    49.  
    50. //出栈
    51. void StackPop(ST* ps)
    52. {
    53. 	assert(ps);
    54. 	assert(ps->top > 0);//判断是否栈空
    55. 	ps->top--;
    56. }
    57.  
    58. //取栈顶元素（并不删除栈顶元素）
    59. STDataType StackTop(ST* ps)
    60. {
    61. 	assert(ps);
    62. 	assert(ps->top > 0);//判断是否栈空
    63. 	return ps->a[ps->top - 1];
    64. }
    65.  
    66. //求栈中元素个数
    67. int StackSize(ST* ps)
    68. {
    69. 	assert(ps);
    70. 	return ps->top;
    71. }
    72.  
    73. //判断是否为空
    74. bool StackEmpty(ST* ps)
    75. {
    76. 	assert(ps);
    77. 	return ps->top == 0;
    78. }

    测试函数

    test.c
    1. #include "Sort.h"
    2.  
    3. void TestOP()
    4. {
    5. 	srand(time(0));
    6. 	const int N = 10000;
    7. 	int* a1 = (int*)malloc(sizeof(int) * N);
    8. 	int* a2 = (int*)malloc(sizeof(int) * N);
    9. 	int* a3 = (int*)malloc(sizeof(int) * N);
    10. 	int* a4 = (int*)malloc(sizeof(int) * N);
    11. 	int* a5 = (int*)malloc(sizeof(int) * N);
    12. 	int* a6 = (int*)malloc(sizeof(int) * N);
    13. 	int* a7 = (int*)malloc(sizeof(int) * N);
    14. 	for (int i = 0; i < N; ++i)
    15. 	{
    16. 		a1[i] = rand();
    17. 		a2[i] = a1[i];
    18. 		a3[i] = a1[i];
    19. 		a4[i] = a1[i];
    20. 		a5[i] = a1[i];
    21. 		a6[i] = a1[i];
    22. 	}
    23. 	int begin1 = clock();
    24. 	InsertSort(a1, N);
    25. 	int end1 = clock();
    26.  
    27. 	int begin2 = clock();
    28. 	ShellSort(a2, N);
    29. 	int end2 = clock();
    30.  
    31. 	int begin3 = clock();
    32. 	SelectSort(a3, N);
    33. 	int end3 = clock();
    34.  
    35. 	int begin4 = clock();
    36. 	HeapSort(a4, N);
    37. 	int end4 = clock();
    38.  
    39. 	int begin5 = clock();
    40. 	QuickSort(a5, 0, N - 1);
    41. 	int end5 = clock();
    42.  
    43. 	int begin6 = clock();
    44. 	MergeSort(a6, N);
    45. 	int end6 = clock();
    46.  
    47. 	int begin7 = clock();
    48. 	//Bubblesort(a7, N);
    49. 	int end7 = clock();
    50.  
    51. 	printf("直接插入排序InsertSort:%d\n", end1 - begin1);
    52. 	printf("希尔排序ShellSort:%d\n", end2 - begin2);
    53. 	printf("选择排序SelectSort:%d\n", end3 - begin3);
    54. 	printf("堆排序HeapSort:%d\n", end4 - begin4);
    55. 	//printf("冒泡排序Bubblesort:%d\n", end7 - begin7);
    56. 	printf("快速排序QuickSort:%d\n", end5 - begin5);
    57. 	printf("归并排序MergeSort:%d\n", end6 - begin6);
    58.  
    59. 	printf("快速排序次数callCount:%d\n", callCount);
    60. 	printf("%p\n", &callCount);
    61. 	free(a1);
    62. 	free(a2);
    63. 	free(a3);
    64. 	free(a4);
    65. 	free(a5);
    66. 	free(a6);
    67. 	//free(a7);
    68. }
    69.  
    70. void TestInsertSort()
    71. {
    72. 	int a[] = { 9,1,2,5,7,4,8,6,3,5 };
    73. 	int sz = sizeof(a) / sizeof(a[0]);
    74. 	InsertSort(a, sz);
    75. 	PrintArry(a, sz);
    76.  
    77. }
    78. void TestShellSort()
    79. {
    80. 	int a[] = { 9,8,7,6,5,4,3,2,1,0 };
    81. 	int sz = sizeof(a) / sizeof(a[0]);
    82.  
    83. 	ShellSort(a, sz);
    84. 	PrintArry(a, sz);
    85. }
    86.  
    87. void TestSelectSort()
    88. {
    89. 	int a[] = { 9,8,7,6,5,4,3,2,1,0 };
    90. 	int sz = sizeof(a) / sizeof(a[0]);
    91.  
    92. 	SelectSort(a, sz);
    93. 	PrintArry(a, sz);
    94. }
    95.  
    96. void TestHeapSort()
    97. {
    98. 	int a[] = { 9,8,7,6,5,4,3,2,1,0 };
    99. 	int sz = sizeof(a) / sizeof(a[0]);
    100.  
    101. 	HeapSort(a, sz);
    102. 	PrintArry(a, sz);
    103. }
    104.  
    105. void TestBubbleSort()
    106. {
    107. 	int a[] = { 9,8,7,6,5,4,3,2,1,0 };
    108. 	int sz = sizeof(a) / sizeof(a[0]);
    109.  
    110. 	Bubblesort(a, sz);
    111. 	PrintArry(a, sz);
    112. }
    113.  
    114. void TestQuickSortSort()
    115. {
    116. 	int a[] = { 6,1,2,7,9,3,4,5,10,8 };
    117. 	int sz = sizeof(a) / sizeof(a[0]);
    118.  
    119. 	QuickSort(a, 0, sz-1);
    120. 	PrintArry(a, sz);
    121. }
    122.  
    123. void TestQuickSortNonRSort()
    124. {
    125. 	int a[] = { 6,1,2,7,9,3,4,5,10,8 };
    126. 	int sz = sizeof(a) / sizeof(a[0]);
    127.  
    128. 	QuickSortNonR(a, 0, sz - 1);
    129. 	PrintArry(a, sz);
    130. }
    131.  
    132. void TestMergeSortSort()
    133. {
    134. 	int a[] = { 6,1,2,7,9,3,4,5,10,8 };
    135. 	int sz = sizeof(a) / sizeof(a[0]);
    136.  
    137. 	MergeSort(a, sz);
    138. 	PrintArry(a, sz);
    139.  
    140. }
    141.  
    142. void TestMergeSortNonR()
    143. {
    144. 	int a[] = { 6,1,2,7,9,3,4,5,10,8 };
    145. 	int sz = sizeof(a) / sizeof(a[0]);
    146.  
    147. 	MergeSortNonR(a, sz);
    148. 	PrintArry(a, sz);
    149. }
    150.  
    151. int main()
    152. {
    153. 	//TestInsertSort();
    154. 	//TestBubbleSort();
    155. 	//TestQuickSortSort();
    156. 	//TestQuickSortNonRSort();
    157. 	//TestHeapSort();
    158. 	//TestMergeSortSort();
    159. 	//estMergeSortNonR();
    160.  
    161. 	TestOP();
    162.  
    163. 	return 0;
    164. }

    本文讲解完毕啦，本文字数：4.2w。创作不易，喜欢的话留下一个免费的赞吧 ╰(°▽°)╯
    感谢阅读

  • 相关阅读:
    Step2：Java内存区域与内存溢出异常
    四氧化三铁Fe3O4/二氧化硅SiO2/二氧化钛TIO2/氧化锌ZNO/二氧化锰MnO2/二硫化钨MoS2/二硒化钨WSe2/碲化钨WTe2纳米粒包载顺铂
    【HuggingFace轻松上手】基于Wikipedia的知识增强预训练
    PTA 7-48 将数倒置
    通信行业专业术语
    HMS Core手语服务荣获2022中国互联网大会“特别推荐案例”：助力建设数字社会
    cmake 教程
    一文看懂推荐系统：经典双塔模型：微软DSSM模型（Deep Structured Semantic Models），无特征交互，后来美团改进了
    微信小程序获取用户头像和昵称能力调整！新的代替方案！
    eclipse进入断点之后，一直卡死，线程一直在运行【记录一种情况】
  • 原文地址：https://blog.csdn.net/2301_77649794/article/details/133737047