• 数据结构--排序

    1. 排序的概念及运用

    1.1 排序的概念

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

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

            内部排序：数据元素全部放在内存中的排序。

            外部排序：数据元素太多不能同时放在内存中，根据排序过程的要求不能在内外存之间移动数据的排序。

    1.2 常见的排序算法

            常见的算法有四种：插入排序，选择排序，交换排序，归并排序。

            插入排序：直接插入排序和希尔排序。

            选择排序：选择排序和堆排序。

            交换排序：冒泡排序和快速排序。

            归并排序：归并排序。

    2.常见排序算法的实现

    2.1 插入排序

    2.1.1基本思想

           直接插入排序是一种简单的插入排序法，其基本思想是： 把待排序的记录按其关键码值的大小逐个插入到一个已经排好序的有序序列中，直到所有的记录插入完为 止，得到一个新的有序序列 。 实际中我们玩扑克牌时，就用了插入排序的思想

    2.1.2 直接插入排序

            

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

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

            1. 元素集合越接近有序，直接插入排序算法的时间效率越高

            2. 时间复杂度：O(N^2)

            3. 空间复杂度：O(1)，它是一种稳定的排序算法

            4. 稳定性：稳定

    直接插入排序的代码实现

    1. void InsertSort(int *a,int n) {
    2. 	for (int i = 1; i < n; ++i) {
    3. 		int tmp = a[i];
    4. 		int end = i-1;
    5. 		while (end >= 0) {
    6. 			if (a[end] > tmp) {
    7. 				a[end + 1] = a[end];
    8. 				--end;
    9. 			}
    10. 			else {
    11. 				break;
    12. 			}
    13. 			a[end + 1] = tmp;
    14. 		}
    15. 	}	
    16. }
    2.1.3 希尔排序

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

    希尔排序的特性总结：

            1. 希尔排序是对直接插入排序的优化。

            2. 当gap > 1时都是预排序，目的是让数组更接近于有序。当gap == 1时，数组已经接近有序的了，这样就 会很快。这样整体而言，可以达到优化的效果。我们实现后可以进行性能测试的对比。

            3. 希尔排序的时间复杂度不好计算，因为gap的取值方法很多，导致很难去计算，因此在好些树中给出的 希尔排序的时间复杂度都不固定：

            4. 稳定性：不稳定

    希尔排序代码实现

    1. void ShellSort(int *a,int n) {
    2. 	/*int gap = 3;
    4. for (int j = 0; j < gap; ++j)
    5. {
    6. 	for (int i = j; i < n - gap; i += gap)
    7. 	{
    8. 		int end = i;
    9. 		int tmp = a[end + gap];
    10. 		while (end >= 0)
    11. 		{
    12. 			if (tmp < a[end])
    13. 			{
    14. 				a[end + gap] = a[end];
    15. 				end -= gap;
    16. 			}
    17. 			else
    18. 			{
    19. 				break;
    20. 			}
    21. 		}
    22. 		a[end + gap] = tmp;
    23. 	}
    24. }*/
    25. // 1、gap > 1  预排序
    26. // 2、gap == 1 直接插入排序
    27. 	int gap = n;
    28. 	while (gap > 1) {
    29. 		gap = gap / 3 + 1;
    30. 		for (int i = 0; i < n - gap; i++) {
    31. 			int end = i;
    32. 			int tmp = a[end+gap];
    33. 			while (end >= 0) {
    34. 				if (a[end] > tmp) {
    35. 					a[end + gap] = a[end];
    36. 					end -= gap;
    37. 				}
    38. 				else {
    39. 					break;
    40. 				}
    41. 				
    42. 			}
    43. 			a[end + gap] = tmp;
    44. 		}
    45. 	}
    46. }

    2.2 选择排序

    2.2.1基本思想：

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

    2.2.2 直接选择排序

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

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

            1. 直接选择排序思考非常好理解，但是效率不是很好。实际中很少使用

            2. 时间复杂度：O(N^2)

            3. 空间复杂度：O(1)

            4. 稳定性：不稳定

    直接选择排序代码实现

    1. void Swap(int* a, int* b) {
    2. 	int tmp = *a;
    3. 	*a = *b;
    4. 	*b = tmp;
    5. }
    6.  
    7. void SelectSort(int* a, int n) {
    8. 	int begin = 0;
    9. 	int end = n - 1;
    10. 	while (begin < end) {
    11. 		int max = end, mini = begin;
    12. 		for (int i = begin+1; i <= end; i++) {
    13. 			if (a[i] < a[mini]) {
    14. 				mini = i;
    15. 			}
    16. 			if (a[i] > a[max]) {
    17. 				max = i;
    18. 			}
    19. 		}
    20. 		Swap(&a[mini], &a[begin]);
    21. 		if (max == begin) {
    22. 			max = mini;
    23. 		}
    24. 		Swap(&a[max], &a[end]);
    25. 		--end;
    26. 		++begin;
    27. 	}
    28. 	
    29. }
    2.2.3 堆排序

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

    堆排序的特性总结：

            1. 堆排序使用堆来选数，效率就高了很多。

            2. 时间复杂度：O(N*logN)

            3. 空间复杂度：O(1)

            4. 稳定性：不稳定

    堆排序代码实现

    1. void Swap(int* a, int* b) {
    2. 	int tmp = *a;
    3. 	*a = *b;
    4. 	*b = tmp;
    5. }
    6.  
    7. void AdjustDown(int* a, int size, int root) {
    8. 	int parent = root;
    9. 	int child = parent * 2 + 1;
    10. 	while (child < size) {
    11. 		if (child + 1 < size && a[child + 1] > a[child]) {
    12. 			++child;
    13. 		}
    14. 		if (a[child] > a[parent]) {
    15. 			Swap(&a[child], &a[parent]);
    16. 			parent = child;
    17. 			child = parent * 2 + 1;
    18. 		}
    19. 		else {
    20. 			break;
    21. 		}
    22. 	}
    23. }
    24. void HeapSort(int* a, int n) {
    25. 	for (int i = (n-1-1)/2; i >=0; i--) {
    26. 		AdjustDown(a, n, i);
    27. 	}
    28. 	int end = n - 1;
    29. 	while (end > 0) {
    30. 		Swap(&a[end], &a[0]);
    31. 		AdjustDown(a, end, 0);
    32. 		--end;
    33. 	}
    34. }

    2.3 交换排序

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

    2.3.1 冒泡排序

    冒泡排序的特性总结：

            1. 冒泡排序是一种非常容易理解的排序

            2. 时间复杂度：O(N^2)

            3. 空间复杂度：O(1)

            4. 稳定性：稳定

    冒泡排序代码实现

    1. void Swap(int* a, int* b) {
    2. 	int tmp = *a;
    3. 	*a = *b;
    4. 	*b = tmp;
    5. }
    6. void BubbleSort(int* a, int n) {
    7. 	for (int j = 0; j < n; j++) {
    8. 		for (int i = 1; i < n-j; i++) {
    9. 			if (a[i - 1] > a[i]) {
    10. 				Swap(&a[i - 1], &a[i]);
    11. 			}
    12. 		}
    13. 	}
    14. 	
    15. }
    16. void PrintArray(int* a, int n)
    17. {
    18. 	for (int i = 0; i < n; ++i)
    19. 	{
    20. 		printf("%d ", a[i]);
    21. 	}
    22. 	printf("\n");
    23. }
    2.3.2 快速排序

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

            快速排序中按照基准值将区间划分为左右两半部分常见的方式有三种：

    1. hoare版本

    2. 挖坑法

    3. 前后指针法

    快速排序的特性总结：

            1. 快速排序整体的综合性能和使用场景都是比较好的，所以才敢叫快速排序

            2. 时间复杂度：O(N*logN)

            3. 空间复杂度：O(logN)

            4. 稳定性：不稳定

    快速排序代码实现

    1. void Swap(int* a, int* b) {
    2. 	int tmp = *a;
    3. 	*a = *b;
    4. 	*b = tmp;
    5. }
    6. //三数取中
    7. int GetMidIndex(int* a, int left, int right) {
    8. 	int mid = left + (left + right) / 2;
    9. 	if (a[left] < a[mid]) {
    10. 		if (a[mid] < a[right]) {
    11. 			return mid;
    12. 		}
    13. 		else if (a[right] < a[left]) {
    14. 			return left;
    15. 		}
    16. 		else {
    17. 			return right;
    18. 		}
    19. 	}
    20. 	else {
    21. 		if (a[mid] > a[right]) {
    22. 			return mid;
    23. 		}
    24. 		else if (a[right] > a[left]) {
    25. 			return left;
    26. 		}
    27. 		else {
    28. 			return right;
    29. 		}
    30.  
    31. 	}
    32. }
    33.  
    34. //hore法
    35. int PartSort1(int* a, int left, int right) {
    36. 	int key = left;
    37. 	while (left < right) {
    38. 		while (left < right && a[right] >= a[key]) {
    39. 			--right;
    40. 		}
    41. 		while (left < right && a[left] <= a[key] ) {
    42. 			++left;
    43. 		}
    44. 		Swap(&a[right], &a[left]);
    45. 	}
    46. 	Swap(&a[right], &a[key]);
    47. 	return left;
    48. }
    49.  
    50.  
    51. //挖坑法
    52. int PartSort2(int* a, int left, int right) {
    53. 	int key = a[left];
    54. 	int pit = left;
    55. 	while (left < right) {
    56. 		// 右边先走，找小
    57. 		while (left < right && a[right] >= key)
    58. 		{
    59. 			--right;
    60. 		}
    61.  
    62. 		a[pit] = a[right];
    63. 		pit = right;
    64.  
    65. 		// 左边走，找大
    66. 		while (left < right && a[left] <= key)
    67. 		{
    68. 			++left;
    69. 		}
    70.  
    71. 		a[pit] = a[left];
    72. 		pit = left;
    73. 	}
    74. 	a[pit] = key;
    75. 	return pit;
    76.  
    77. }
    78.  
    79. //前后指针法
    80. int PartSort3(int* a, int left, int right) {
    81. 	//int midi = GetMidIndex(a, left, right);
    82. 	//Swap(&a[midi], &a[left]);
    83. 	int key = left;
    84. 	int cur = left + 1;
    85. 	int prev = left;
    86. 	while (cur <= right) {
    87.  
    88. 		if (a[key] > a[cur]) {
    89. 			++prev;
    90. 			Swap(&a[prev], &a[cur]);
    91. 		}
    92. 		++cur;
    93. 	}
    94. 	Swap(&a[prev], &a[key]);
    95. 	key = prev;
    96. 	return key;
    97. }
    98.  
    99. void QuickSort1(int* a, int begin, int end) {
    100. 	if (begin >= end) {
    101. 		return;
    102. 	}
    103. 	int key = PartSort3(a, begin, end);
    104. 	QuickSort1(a, begin, key - 1);
    105. 	QuickSort1(a, key+1, end);
    106.  
    107. }
    108.  
    109.  
    110. //三路划分
    111.  void QuickSort2(int* a, int begin, int end) {
    112. 	if (begin >= end) {
    113. 		return;
    114. 	}
    115. 	int left = begin;
    116. 	int right = end;
    117. 	int cur = left + 1;
    118.  
    119. 	int midi = GetMidIndex(a, left, right);
    120. 	Swap(&a[left], &a[midi]);
    121. 	int key = a[left];
    122. 	while (cur <= right) {
    123. 		if (a[cur] < key) {
    124. 			Swap(&a[left], &a[cur]);
    125. 			++left;
    126. 			++cur;
    127. 		}
    128. 		else if (a[cur] > key) {
    129. 			Swap(&a[right], &a[cur]);
    130. 			--right;
    131. 		}
    132. 		else {
    133. 			++cur;
    134. 		}
    135. 	}
    136. 	QuickSort2(a, begin, left- 1);
    137. 	QuickSort2(a, right+1, end);
    138.  
    139. }
    140.  
    141.  
    142. //快速排序非递归方法
    143. void QuickSortNre(int* a, int begin, int end) {
    144. 	Stack st;
    145. 	StackInit(&st);
    146. 	StackPush(&st, begin);
    147. 	StackPush(&st, end);
    148.  
    149. 	while (!StackEmpty(&st)){
    150. 		int right = StackTop(&st);
    151. 		StackPop(&st);
    152. 		int left = StackTop(&st);
    153. 		StackPop(&st);
    154.  
    155. 		int keyi = PartSort3(a, left, right);
    156. 		if (keyi+1 < right) {
    157. 			StackPush(&st, keyi+1);
    158. 			StackPush(&st, right);
    159. 		}
    160. 		if (keyi -1 > left) {
    161. 			StackPush(&st, left);
    162. 			StackPush(&st, keyi -1);
    163. 			
    164. 		}
    165. 	}
    166. 	StackDestroy(&st);
    167. }

    2.4 归并排序

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

    归并排序的特性总结：

            1. 归并的缺点在于需要O(N)的空间复杂度，归并排序的思考更多的是解决在磁盘中的外排序问题。

            2. 时间复杂度：O(N*logN)

            3. 空间复杂度：O(N)

            4. 稳定性：稳定

    归并排序代码实现

    1. void _MergeSort(int* a, int begin,int end,int *tmp) {
    2. 	if (begin >= end) {
    3. 		return;
    4. 	}
    5. 	int mid = (begin + end) / 2;
    6. 	_MergeSort(a,begin,mid,tmp);
    7. 	_MergeSort(a,mid+1,end,tmp);
    8. 	int begin1 = begin,end1=mid; 
    9. 	int begin2 = mid + 1, end2 = end;
    10. 	int index = begin;
    11. 	while (begin1 <= end1 && begin2 <= end2) {
    12. 		if (a[begin1] < a[begin2]) {
    13. 			tmp[index++] = a[begin1++];
    14. 		}
    15. 		else {
    16. 			tmp[index++] = a[begin2++];
    17.  
    18. 		}
    19. 	}
    20. 	while (begin1 <= end1) {
    21. 		tmp[index++] = a[begin1++];
    22. 	}
    23. 	while (begin2 <= end2) {
    24. 		tmp[index++] = a[begin2++];
    25.  
    26. 	}
    27. 	memcpy(a + begin, tmp + begin, sizeof(int) * (end - begin + 1));
    28. }
    29. void MergeSort(int* a, int n) {
    30. 	int* tmp = (int*)malloc(sizeof(int) * n);
    31. 	if (tmp == NULL) {
    32. 		perror("malloc fail");
    33. 	}
    34. 	_MergeSort(a, 0, n-1, tmp);
    35. 	free(tmp);
    36. }
    37.  
    38.  非递归
    39. void MergeSortNonr(int* a, int n) {
    40. 	int* tmp = (int*)malloc(sizeof(int) * n);
    41. 	if (tmp == NULL) {
    42. 		perror("malloc fail");
    43. 	}
    44. 	int gap = 1;
    45. 	while (gap < n) {
    46. 		for (int i = 0; i < n; i += 2 * gap) {
    47. 			int begin1 = i, end1 = i + gap - 1;
    48. 			int begin2 = i + gap, end2 = i + 2 * gap - 1;
    49. 			if (end1 >= n || begin2 >= n) {
    50. 				break;
    51. 			}
    52. 			if (begin2 < n && end2 >= n) {
    53. 				end2 = n - 1;
    54. 			}
    55. 			int index = i;
    56. 			while (begin1 <= end1 && begin2 <= end2) {
    57. 				if (a[begin1] < a[begin2]) {
    58. 					tmp[index++] = a[begin1++];
    59. 				}
    60. 				else {
    61. 					tmp[index++] = a[begin2++];
    62.  
    63. 				}
    64. 			}
    65. 			while (begin1 <= end1) {
    66. 				tmp[index++] = a[begin1++];
    67. 			}
    68. 			while (begin2 <= end2) {
    69. 				tmp[index++] = a[begin2++];
    70.  
    71. 			}
    72. 			memcpy(a + i, tmp + i, sizeof(int) * (end2 - i + 1));
    73. 		}
    74. 		gap *= 2;
    75. 	}	
    76. }

    2.5 非比较排序

     计数排序

    思想：

            计数排序又称为鸽巢原理，是对哈希直接定址法的变形应用。 操作步骤：
                    1. 统计相同元素出现次数
                    2. 根据统计的结果将序列回收到原来的序列中
    计数排序的特性总结：
            1. 计数排序在数据范围集中时，效率很高，但是适用范围及场景有限。
            2. 时间复杂度：O(MAX(N,范围))
            3. 空间复杂度：O(范围)
            4. 稳定性：稳定

    代码实现

    1. void CountSort(int* a, int n) {
    2. 	int min = a[0];
    3. 	int max = a[0];
    4. 	for (int i = 1; i < n; i++) {
    5. 		if (a[i] > max) {
    6. 			max = a[i];
    7. 		}
    8. 		if(a[i]
    9. 			min = a[i];
    10. 		}
    11. 	}
    12. 	int range = max - min + 1;
    13. 	int* CountA = (int*)malloc(sizeof(int) * range);
    14. 	assert(CountA);
    15. 	memset(CountA, 0, sizeof(int) * range);
    16. 	for (int i = 0; i < n; i++) {
    17. 		CountA[a[i] - min]++;
    18. 	}
    19. 	int j = 0;
    20. 	for (int i = 0; i < range; i++) {
    21. 		while (CountA[i]--) {
    22. 			a[j++] = i+min;
    23. 		}
    24. 	}
    25. }

    3. 排序算法稳定性

    定义

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

  • 相关阅读:
    LeetCode 513找树左下角的值 112路径总和113路径总和ii 106从中序与后序遍历序列构造二叉树
    从kafka如何保证数据一致性看通常数据一致性设计
    基于Spring Boot+MyBatis+MySQL的高校试卷管理系统
    云计算技术 — 混合云 — 技术架构
    现状分析：“一云多芯”如何推动信创项目快速部署
    Android 编译插桩操纵字节码
    广州蓝景分享—开发人员都知道的JavaScript技巧
    全国临床遗传学及遗传咨询培训在湘举行,为18省培训百名医师
    Python tkinter -- 第15章 Combobox
    苹果MAC电脑如何清理垃圾加速运行速度?
  • 原文地址：https://blog.csdn.net/weixin_63219391/article/details/136589979