• 【数据结构初阶】九、排序的讲解和实现（直接插入 \ 希尔 \ 直接选择 \ 堆 \ 冒泡 -- C语言）

    =========================================================================

    相关代码gitee自取：

    C语言学习日记: 加油努力 (gitee.com)

     =========================================================================

    接上期：

    【数据结构初阶】八、非线性表里的二叉树（二叉树的实现 -- C语言链式结构）-CSDN博客

     =========================================================================

                         

    排序

    排序的概念

    所谓排序，就是使一串记录，
    按照其中的某个或某些关键字的大小，递增或递减排列起来的操作
                     

    稳定性

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

                     

    内部排序（内排序）

    数据元素全部放在内存中的排序（在内存中进行排序）

    属于内排序的排序算法：
    • 插入排序：
      直接插入排序 、希尔排序
                     
    • 选择排序：
      直接选择排序 、堆排序
                      
    • 交换排序：
      冒泡排序 、快速排序
                     
    • 并归排序（即属于内排序又属于外排序）

                     

    外部排序（外排序）

    数据元素太多，不能同时放在内存中，

    根据排序过程的要求不能在内外存之间移动数据的排序，

    即在磁盘中（“顺序写顺序读”）进行排序

    属于外排序的排序算法：
    • 并归排序（即属于内排序又属于外排序）

                    

    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

                     

    常见排序算法的实现

    （详细解释在图片的注释中，代码分文件放下一标题处）

                       

    一、插入排序

                            

    插入排序 -- 直接插入排序

    直接插入排序是一种简单的插入排序法

                     

    该算法基本思想：

    把待排序的记录按其关键码值的大小逐个插入到一个已经排好序的有序序列中，

    直到所有的记录插入完为止，得到一个新的有序序列
    （想象我们玩扑克牌时，给扑克牌大小排序就用了插入排序的思想）

                          

    实现思路：

    当插入第 i(i>=1) 个元素时，
    前面的 array[0]，array[1]，…，array[i-1] 已经排好序，
    此时用 array[i] 的排序码与 array[i-1]，array[i-2]，… 的排序码顺序进行比较，
    找到插入位置后就将 array[i] 插入，原来位置上的元素顺序后移（覆盖）
                         

    直接插入排序的特性总结：
    • 元素越接近有序，直接插入排序算法的时间效率越高 -- 最高可达O(N)
                              
    • 该算法时间复杂度：O(N^2) -- 最坏的情况下(逆序)
                                  
    • 该算法空间复杂度：O(1)
                            
    • 该算法稳定性：稳定
                        

    ---------------------------------------------------------------------------------------------

                           

    InsertSort函数 -- 直接插入排序实现函数

    • 使用for循环进行循环插入排序，
      再设置 “前元素” 和 “后元素”
                             
    • for循环中：
      使用while循环为“后元素”寻找合适位置，
      找到后再将 “后元素” 插入，
      之后再次进行for循环让下个“后元素”插入合适位置
    图示：

    该函数执行逻辑图：

    对应函数测试：

                

                

    ---------------------------------------------------------------------------------------------

                

    插入排序 -- 希尔排序（缩小增量排序）

    希尔排序又称缩小增量法。

                 

    该算法基本思想：

    先选定一个整数gap值，把待排序文件中所有记录分成gap个组，

    所有距离为gap的记录分在同一组内，并对每一组内的记录进行直接插入排序，

    然后换个整数gap值再取gap组，重复上述分组和排序的工作，

    当 gap=1 时，所有记录在同一组内时已经排好序了

                   

    希尔排序的特性总结：
    • 希尔排序是对直接插入排序的优化
                    
    • 当 gap>1 时都是在进行预排序，目的是让数组更接近于有序，
      当 gap==1 时，数组已经接近有序的了，这样再进行直接插入排序就会很快，
      这样整体而言，可以达到优化的效果
                                    
    • 希尔排序的时间复杂度不好计算，因为gap的取值方法很多，导致很难去计算，
      因此在一些书中给出的希尔排序的时间复杂度也不固定，
      该函数大概的时间复杂度为：O(N^1.3)
                             
    • 该算法稳定性：不稳定
                               

    ---------------------------------------------------------------------------------------------

                           

    ShellSort函数 -- 希尔排序实现函数

    • 核心实现操作还是直接插入排序，
      但是在对所有值进行直接插入排序前先进行多次预排序操作，
      （预排序也是用直接插入排序完成）
      让数组达到尽量有序的状态
                    
    • 定义gap值变量，使用while循环控制多次预排序
      （当gap==1时，就相当于直接插入排序）
                      
    • while循环中内嵌for循环完成“当前gap组”的预排序
                       
    • 再内嵌for循环完成“当前gap组”其中一组的预排序
      （通过直接插入排序的方式实现）
                      
      • 最后再内嵌while循环配合完成直接插入排序
    图示：

    该函数执行逻辑图：

    对应函数测试：

                         

                         

                        

    二、选择排序

    基本思想：

    每一趟排序从待排序的数组元素中分别选择出最小和最大的一个元素，
    再分别存放在数组的起始位置和尾部位置，
    直到全部待排序的数组元素排序完成

                    

                    

    选择排序 -- 直接选择排序

                        

    该算法基本思想：

    在元素集合 array[i] -- array[n-1] 中选择获取当前最小值元素和当前最大值元素，
    将当前最小值元素交换后放到当前数组的起始位置，
    将当前最大值元素交换后放到当前数组的尾部位置，

    在剩余的 array[i+1] -- array[n-2] 集合中，重复上述操作，直到集合剩余1个元素
                   

    直接选择排序的特性总结：
    • 直接选择排序比较好理解，但是效率不高，实际很少使用
                        
    • 该算法时间复杂度：O(N^2)
                           
    • 该算法空间复杂度：O(1)
                         
    • 该算法稳定性：不稳定
                           

    ---------------------------------------------------------------------------------------------

                           

    SelectSort函数 -- 直接选择排序实现函数

    • 定义 数组开始(初始)位置下标begin 和 数组尾部(结束)位置下标end 变量，
      使用while循环控制多趟直接选择排序
                          
    • （在while循环中：完成一趟直接选择排序）
      定义 存放当前最小值下标mini 和 存放当前最大值下标maxi 变量，
      内嵌for循环，遍历一次当前数组找到当前最大值和当前最小值
                         
    • （while循环中for循环外：）
      将找到的当前数组最小值放入数组起始（左边）位置，
      当前数组最大值放入数组尾部（右边）位置,
      完成两值的排序后，调整 begin 和 end 变量，缩小数组范围准备下趟直接选择排序
    图示：

    该函数执行逻辑图：

    对应函数测试：

                

                

    ---------------------------------------------------------------------------------------------

                

    选择排序 -- 堆排序

    堆是一种完全二叉树，
    可以使用堆中的向下调整操作对普通数组进行排序（升序或降序）

                   

    堆排序的特性总结：
    • 堆排序使用堆进行选择排序，效率就高了很多
                        
    • 该算法时间复杂度：O(N*logN)
                           
    • 该算法空间复杂度：O(1)
                         
    • 该算法稳定性：不稳定
                           

    ---------------------------------------------------------------------------------------------

                           

    堆排序的实现往期博客中已有详细描述：

    【数据结构初阶】七、非线性表里的二叉树（堆的实现 -- C语言顺序结构）-CSDN博客

    （包含堆排序的 实现函数、图示、对应函数执行逻辑图、函数测试、原代码）

                         

                         

                        

    三、交换排序

    基本思想：

    所谓交换，就是根据序列中两个记录键值的比较结果来交换这两个记录在序列中的位置

                 

    交换排序的特点：

    将键值较大的记录向序列的尾部移动，键值较小的记录向序列的前部移动

                          

                          

    交换排序 -- 冒泡排序

                         

    该算法基本思想：

    数组中的元素1和元素2进行比较，如果元素1大于元素2，则交换两者位置；

    再比较此时的元素2和元素3，如果元素2大于元素3，则交换两者位置；

    再比较此时的元素3和元素4……

    一趟冒泡排序完成后，就能完成当前数组中最大值的排序（排在尾部），
    再进行下一趟冒泡排序前要缩小数组排序范围（排除已经排序好的最大值），

    这样多趟冒泡排序完成后就能完成数组的排序

                         

    冒泡排序的特性总结：
    • 冒泡排序是一种非常容易理解的排序
                        
    • 该算法时间复杂度：O(N^2)
                    
    • 该算法空间复杂度：O(1)
                            
    • 该算法稳定性：稳定
                             

    ---------------------------------------------------------------------------------------------

                           

    BubbleSort函数 -- 冒泡排序实现函数

    • 定义嵌套for循环完成冒泡排序，
      外层for循环控制当前数组范围，数组范围慢慢减小，
      减到变成1时排序完成（至少有两个数才能比较）
                              
    • 内层for循环循环一趟完成当前数组范围内的最值的排序
                          
    • 在当前冒泡排序过程中，
      设置一个变量exchange记录当前一趟冒泡排序过程中是否有发生元素的交换，
      一趟冒泡排序后，如果没有任何元素发生交换，
      说明目前已经排好序了，那就直接终止之后的冒泡排序
    图示：

    该函数执行逻辑图：

    对应函数测试：

                     

    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

                          

    对应代码：

    Sort.h -- 排序头文件

    1. #pragma once
    2.  
    3. //包含之后所需头文件：
    4. #include 
    5.  
    6. //打印数组函数：
    7. void PrintArray(int* a, int n);
    8.  
    9.  
    10. //直接插入排序函数：
    11. //第一个参数：接收要排序的数组首元素地址（a）
    12. //第二个参数：接收该数组的长度（n）
    13. void InsertSort(int* a, int n);
    14.  
    15.  
    16. //希尔排序函数：
    17. //第一个参数：接收要排序的数组首元素地址（a）
    18. //第二个参数：接收该数组的长度（n）
    19. void ShellSort(int* a, int n);
    20. //1、预排序：分组排，间隔为gap(间距间隔)分为一组
    21. //				预排序意义：
    22. // 让大的数更快的到数组后面，小的数更快的到数组前面，
    23. // gap值越大“跳”得越快，但是越不接近有序
    24. // gap值越小“跳”得越慢，但是越接近有序
    25. // 当gap==1时，就相当于直接插入排序
    26. //2、直接插入排序
    27.  
    28.  
    29. //冒泡排序函数：
    30. //第一个参数：接收要排序的数组首元素地址（a）
    31. //第二个参数：接收该数组的长度（n）
    32. void BubbleSort(int* a, int n);	
    33.  
    34.  
    35. //直接选择排序函数：
    36. //第一个参数：接收要排序的数组首元素地址（a）
    37. //第二个参数：接收该数组的长度（n）
    38. void SelectSort(int* a, int n);

                

                

    ---------------------------------------------------------------------------------------------

                

    Sort.c -- 排序函数实现文件

    1. #define _CRT_SECURE_NO_WARNINGS 1
    2.  
    3. //包含排序头文件：
    4. #include "Sort.h"
    5.  
    6. //打印数组函数：
    7. void PrintArray(int* a, int n)
    8. {
    9. 	for (int i = 0; i < n; i++)
    10. 	{
    11. 		printf("%d ", a[i]);
    12. 	}
    13.  
    14. 	printf("");
    15. }
    16.  
    17.  
    18.  
    19. //直接插入排序函数（升序）：
    20. //第一个参数：接收要排序的数组首元素地址（a）
    21. //第二个参数：接收该数组的长度（n）
    22. void InsertSort(int* a, int n)
    23. {
    24. 	//使用for循环进行循环插入排序：
    25. 		/*
    26. 		要取“前后元素”，“后元素”要依次和“前面所有元素”进行比较，
    27. 		直到“后元素”找到合适位置并插入，而“后元素”下标最大为[n-1]，
    28. 		所以“前元素”下标最大为[n-2]
    29. 		*/
    30. 	for (int i = 0; i < n - 1; i++)
    31. 		//循环到 i = n-2  --  “前元素”下标最大为[n-2]：
    32. 	{
    33. 		//遍历下标的起始位置从 0 开始，到 n-2 结束：
    34. 		int end = i; //“前元素”
    35.  
    36. 		//保存end下标元素的后一个元素：
    37. 		int tmp = a[end + 1]; //“后元素”
    38.  
    39. 		//使用while循环为“后元素”寻找合适位置：
    40. 		//（“后元素”循环和其前面所有元素进行比较，直到找到合适位置）
    41. 		while (end >= 0)
    42. 			//“前面所有元素”：下标 >=0 时就还有 “前元素”，
    43. 			//那“后元素”就需要继续进行比较：
    44. 		{
    45. 			if (tmp < a[end])
    46. 				//“后元素” 小于 “前元素”：
    47. 			{
    48. 				//那就将“前元素(较大)”往后插入（覆盖）:
    49. 				a[end + 1] = a[end];
    50. 				//a[end + 1]，被覆盖的元素还保留在tmp中，
    51. 				//所以不用担心覆盖后找不到“后元素”
    52. 			}
    53. 			else
    54. 				//"后元素" 大于等于 "前元素"：
    55. 			{
    56. 				//说明“后元素”的“前面较大元素”都已经往后覆盖完成了，
    57. 				//找到了"后元素"的恰当位置，
    58. 				//break退出循环将“后元素”tmp插入该位置
    59. 				break;
    60. 			}
    61.  
    62. 			end--;
    63. 			//当前end--，下次循环判断“前前元素”需不需要再往前覆盖，
    64. 			//end减到-1退出while循环的话，说明“后元素”是数组中最小的元素，
    65. 			//导致其前面所有元素都需要往后覆盖挪出位置
    66. 		}
    67.  
    68. 		//注意，合适的位置是[end + 1]，
    69. 		//因为"后元素" 大于等于 "前元素"的话，
    70. 		//那“后元素”就理应排在“前元素”后面，即[end + 1]，
    71. 		a[end + 1] = tmp;
    72. 		//如果是end减到-1退出的while循环，
    73. 		//那[end + 1]就等于0，即数组首元素位置，
    74. 		//让“后元素”排在数组首元素位置
    75. 	}
    76. }
    77. //时间复杂度：
    78. //O(N^2) -- 逆序（最坏情况）
    79. //O(N) -- 顺序有序
    80. //冒泡排序和插入排序论时间复杂度它们是同一档次，
    81. //但在细节上，如局部有序，插入排序会更优
    82.  
    83.  
    84.  
    85. //希尔排序函数：
    86. //第一个参数：接收要排序的数组首元素地址（a）
    87. //第二个参数：接收该数组的长度（n）·
    88. void ShellSort(int* a, int n)
    89. {
    90. 	//定义分组间隔和分组个数：
    91. 	int gap = n;
    92. 	
    93. 	//只要当前预排序gap值还没到1，
    94. 	//while循环就继续循环进行预排序：
    95. 	while (gap > 1)
    96. 	{
    97. 		//变化gap值进行多次预排序，
    98. 		//让数组越来越接近有序：
    99. 		gap = gap / 2;
    100. 		//当 gap > 1 时就是预排序
    101. 		//当 gap == 1 时就是插入排序
    102.  
    103. 		//这个for循环控制 “当前gap组” 的排序：
    104. 		//（一组“gap分”组排完再排另一组gap分组）
    105. 		for (int j = 0; j < gap; j++)
    106. 		/*
    107. 		* 假设gap取3，
    108. 		* 就在数组中以3(gap)为间隔取数为一组（gap分组）
    109. 		* 总共取3(gap)组
    110. 		*/
    111. 		{
    112. 			//这个for循环控制gap组中其中一组的排序：
    113. 			for (int i = 0; i < n - gap; i += gap)
    114. 			/*
    115. 			*					循环条件：n - gap  
    116. 			*控制“前元素end”范围，保证“后元素tmp”通过end取值时不出界
    117. 			*					迭代条件：i += gap
    118. 			*i每次迭代时就+gap，实现以gap为间隔取数为一组（gap分组）
    119. 			*/
    120. 			{
    121. 				//保存当前分组的“前元素”（记录）：
    122. 				int end = i;
    123.  
    124. 				//保存当前分组的“后元素”（记录）：
    125. 				int tmp = a[end + gap];
    126.  
    127. 				//使用while循环为“后元素”寻找合适位置:
    128. 				//(“后元素”循环和其前面所有元素进行比较，直到找到合适位置)
    129. 				//(和直接插入类似，只是值与值间隔不同)
    130. 				while (end >= 0)
    131. 					//“前面所有元素”：下标 >=0 时就还有 “前元素”，
    132. 					//那“后元素”就需要继续进行比较：
    133. 				{
    134. 					if (tmp < a[end])
    135. 						//“后元素” 小于 “前元素”：
    136. 					{
    137. 						//(gap分组中：)
    138. 						//那就将“前元素(较大)”往后插入（覆盖）:
    139. 						a[end + gap] = a[end];
    140. 						//a[end + gap]，被覆盖的元素还保留在tmp中，
    141. 						//所以不用担心覆盖后找不到“后元素”
    142.  
    143. 						end -= gap;
    144. 						//(gap分组中：)
    145. 						//当前end-=gap，下次循环判断“前前元素”需不需要再往前覆盖，
    146. 						//end减到<0时，退出while循环的话，说明“后元素”是数组中最小的元素，
    147. 						//导致其前面所有元素都需要往后覆盖挪出位置
    148. 					}
    149. 					else
    150. 						//"后元素" 大于等于 "前元素"：
    151. 					{
    152. 						//说明“后元素”的“前面较大元素”都已经往后覆盖完成了，
    153. 						//找到了"后元素"的恰当位置，
    154. 						//break退出循环将“后元素”tmp插入该位置
    155. 						break;
    156. 					}
    157. 				}
    158.  
    159. 				//注意，合适的位置是[end + gap]，
    160. 				//因为"后元素" 大于等于 "前元素"的话，
    161. 				//那“后元素”就理应排在“前元素”后面，即[end + gap]，
    162. 				a[end + gap] = tmp;
    163. 				//如果是 end减到<0 退出的while循环，
    164. 				//那[end + gap]就找到当前gap组首元素位置，
    165. 				//让“后元素”排在当前gap组首元素位置
    166. 			}
    167. 		}
    168. 	}
    169. }
    170.  
    171.  
    172.  
    173. //两值交换函数：
    174. void Swap(int* x, int* y)
    175. {
    176. 	//创建中间值进行值的交换：
    177. 	int tmp = *x;
    178. 	*x = *y;
    179. 	*y = tmp;
    180. }
    181.  
    182.  
    183.  
    184. //冒泡排序函数：
    185. //第一个参数：接收要排序的数组首元素地址（a）
    186. //第二个参数：接收该数组的长度（n）
    187. void BubbleSort(int* a, int n)
    188. {
    189. 	/*
    190. 	* 定义嵌套for循环完成冒泡排序：
    191. 	* 内层for循环一趟完成当前数组范围内的最值的排序
    192. 	* 外层for循环则控制当前数组范围
    193. 	* 数组范围慢慢减小，减到变成1时排序完成
    194. 	* （至少有两个数才能比较）
    195. 	*/
    196.  
    197. 	//这个for循环控制内嵌for循环的数组范围：
    198. 	for (int j = 0; j < n; j++)
    199. 	{
    200. 		int exchange = 0; 
    201. 		//如果没发生交换该变量就为0
    202.  
    203. 		//内嵌for循环进行循环比较交换：
    204. 		for (int i = 1; i < n-j; i++)
    205. 		/*
    206. 		*n-j ：通过判断条件控制数组范围
    207. 		*因为一趟下来就完成一个当前最值的排序，
    208. 		*下次再排序的数组范围就要排除这个已经排好序的最值，
    209. 		*通过外部for循环的j来控制数组范围：
    210. 		*/
    211. 		{
    212. 			if (a[i - 1] > a[i])
    213. 				//如果“前元素” 大于 “当前元素”：
    214. 				//（ i 从1开始）
    215. 			{
    216. 				//进行交换：
    217. 				Swap(&a[i - 1], &a[i]);
    218.  
    219. 				exchange = 1;
    220. 				//如果发生了变化该变量就为1
    221. 			}
    222. 		}
    223. 		/*
    224. 		* 内嵌for循环整个执行完就是一趟，
    225. 		* 当遇到最大值后，因为最大所以会一直被交换
    226. 		* 直到被交换至数组尾部，
    227. 		* 这就完成了当前数组最大值的排序
    228. 		*/
    229.  
    230. 		if (exchange == 0)
    231. 			//一趟冒泡排序后，如果没有发生交换：
    232. 		{
    233. 			//说明目前已经排好序了，
    234. 			//就没必要再进行之后的冒泡排序了：
    235. 			break;
    236. 		} 
    237. 	}
    238. }
    239.  
    240.  
    241.  
    242. //直接选择排序函数：
    243. //第一个参数：接收要排序的数组首元素地址（a）
    244. //第二个参数：接收该数组的长度（n）
    245. void SelectSort(int* a, int n)
    246. {
    247. 	/*
    248. 	* 思路：
    249. 	* 排序一趟选出当前最小值下标和当前最大值下标,
    250. 	* 通过对应下标将最小值放“左边”，最大值放“右边”
    251. 	*/
    252.  
    253. 	//数组开始位置下标 -- 0
    254. 	int begin = 0;
    255. 	
    256. 	//数组尾部（结束）位置下标 -- n-1
    257. 	int end = n - 1;
    258.  
    259. 	//使用while循环控制多趟直接选择排序：
    260. 	while (begin < end)
    261. 	/*
    262. 	* 只要 begin 还小于 end，左右下标就还没重合
    263. 	* begin 和 end 之间就还有元素要被排序
    264. 	*/
    265. 	{
    266. 		//对当前数组范围进行一趟直接选择排序：
    267.  
    268. 		//存放当前最小值下标：
    269. 		int mini = begin; //默认为下标0
    270.  
    271. 		//存放当前最大值下标：
    272. 		int maxi = begin; //默认为下标0
    273.  
    274. 		//使用for循环遍历一次当前数组，
    275. 		//找到当前最大值和当前最小值：
    276. 		for (int i = begin+1; i <= end; i++)
    277. 		/*
    278. 		* mini 和 maxi 默认下标都是0
    279. 		* 所以循环时下标从[begin+1]开始，等于[n-1]结束
    280. 		*/
    281. 		{
    282. 			//选出当前最大值下标：
    283. 			if (a[i] > a[maxi])
    284. 				//如果“i下标元素”大于“maxi下标元素”：
    285. 			{
    286. 				//将较大值下标i赋给maxi下标：
    287. 				maxi = i;
    288. 			}
    289.  
    290. 			//选出当前最小值下标：
    291. 			if (a[i] < a[mini])
    292. 				//如果“i下标元素”小于“mini下标元素”：
    293. 			{
    294. 				//将较小值下标i赋给mini下标：
    295. 				mini = i;
    296. 			}
    297.  
    298. 		} //(for循环中)
    299.  
    300. 		//将找到的当前数组最小值放入数组起始（左边）位置：
    301. 		Swap(&a[begin], &a[mini]);
    302. 		/*
    303. 		* 注：如果begin下标元素为最大值，
    304. 		* 那么maxi下标也会指向该元素，即begin == maxi，
    305. 		* 当begin元素和mini交换后（只是值交换），
    306. 		* begin 和 maxi下标还是重叠在原位置，指向交换后的mini元素
    307. 		* 此时如果再执行 Swap(&a[end], &a[maxi]);
    308. 		* 就反而会将最小值移到数组尾部去，
    309. 		* 所以要调整 begin==maxi 重叠的情况：
    310. 		*/
    311. 		if (maxi == begin)
    312. 			//排除maxi和begin下标重叠的情况：
    313. 		{
    314. 			//maxi==begin等于当前最大值下标，上面交换后，
    315. 			//当前最大值就在mini下标处，
    316. 			//那就把maxi最大值下标指向mini下标处即可：
    317. 			maxi = mini;
    318. 		}
    319.  
    320. 		//将找到的当前数组最大值放入数组尾部（右边）位置：
    321. 		Swap(&a[end], &a[maxi]);
    322. 	
    323. 		/*
    324. 		* 执行到这就选出了两个最值并放到了合适位置（一趟直接选择排序），
    325. 		* 调整 begin 和 end 下标（调整数组范围），数组范围往中间缩小，
    326. 		* 再开始新一趟直接选择排序：
    327. 		*/
    328. 		++begin;
    329. 		--end;
    330.  
    331. 	} //(while循环中)
    332. }
    333. //时间复杂度：O(N^2)

                

                

    ---------------------------------------------------------------------------------------------

                

    Test.c -- 排序测试文件

    1. #define _CRT_SECURE_NO_WARNINGS 1
    2.  
    3. //包含排序头文件：
    4. #include "Sort.h"
    5.  
    6. //插入排序测试：
    7. void ISTest()
    8. {
    9. 	//创建要进行插入排序的数组：
    10. 	int a[] = { 3,4,2,1,5 };
    11.  
    12. 	//调用插入排序函数进行排序：
    13. 	InsertSort(a, 5);
    14.  
    15. 	//循环打印排序后的数组：
    16. 	printf("使用直接插入排序后的数组:> ");
    17. 	for (int i = 0; i < 5; i++)
    18. 	{
    19. 		printf("%d ", a[i]);
    20. 	}
    21. }
    22.  
    23.  
    24. //希尔排序测试：
    25. void SSTest()
    26. {
    27. 	//创建要进行插入排序的数组：
    28. 	int a[] = { 9,1,2,5,7,4,8,6,3,5 };
    29.  
    30. 	//调用希尔排序函数进行排序：
    31. 	ShellSort(a, sizeof(a) / sizeof(int));
    32.  
    33. 	//使用自定义打印函数打印排序后数组：
    34. 	printf("使用希尔排序后的数组:> ");
    35. 	PrintArray(a, sizeof(a) / sizeof(int));
    36. }
    37.  
    38.  
    39. //冒泡排序测试：
    40. void BSTest()
    41. {
    42. 	//创建要进行插入排序的数组：
    43. 	int a[] = { 9,1,2,5,7,4,8,6,3,5 };
    44.  
    45. 	//调用冒泡排序函数进行排序：
    46. 	BubbleSort(a, sizeof(a) / sizeof(int));
    47.  
    48. 	//使用自定义打印函数打印排序后数组：
    49. 	printf("使用冒泡排序后的数组:> ");
    50. 	PrintArray(a, sizeof(a) / sizeof(int));
    51. }
    52.  
    53.  
    54. //直接选择排序测试：
    55. void SlSTest()
    56. {
    57. 	//创建要进行插入排序的数组：
    58. 	int a[] = { 9,1,2,5,7,4,8,6,3,5 };
    59.  
    60. 	//调用直接选择排序函数进行排序：
    61. 	SelectSort(a, sizeof(a) / sizeof(int));
    62.  
    63. 	//使用自定义打印函数打印排序后数组：
    64. 	printf("使用直接选择排序后的数组:> ");
    65. 	PrintArray(a, sizeof(a) / sizeof(int));
    66. }
    67.  
    68.  
    69. int main()
    70. {
    71. 	//ISTest();
    72. 	//SSTest();
    73. 	//BSTest();
    74. 	SlSTest();
    75.  
    76. 	return 0;
    77. }
  • 相关阅读:
    腾讯季报图解：营收1340亿降3% 马化腾称主动退出非核心业务
    给网站添加“开放搜索描述“以适配浏览器的“站点搜索“
    springboot社区人员管理系统的设计与实现毕业设计源码260839
    【MySQL数据库和JDBC编程】第四章：MySQL索引和事务
    人生中第一次向开源项目提交PR记录
    计算机毕业设计Java“华商转转”平台的设计和实现(源码+系统+mysql数据库+lw文档)
    积分球测量作用
    简单聊一聊Javascript中的模块化
    Python开源项目周排行 2023年第34周
    ROS学习（26）动态参数配置
  • 原文地址：https://blog.csdn.net/weixin_63176266/article/details/133929992