devbox
花生_TL007
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

数据结构与算法—冒泡排序&快速排序

作者：花生_TL007 | 2024-04-23 06:05:34

赞

踩

数据结构与算法—冒泡排序&快速排序

目录

一、交换排序

二、冒泡排序 

特性

三、快速排序

1、三种一次划分操作 

Hoare法

挖洞法

前后指针法 

三种方法总结： 

2、改进划分效率 

3、递归实现快速排序

4、非递归实现快速排序

 栈的函数：

非递归排序函数：

5、特性 

 完整代码：

 声明头文件：

 排序函数：

 测试函数：

一、交换排序

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

二、冒泡排序 

  1. void BubbleSort(int* a, int n)
  2. {
  3. 	for (int j = 0; j < n; ++j)
  4. 	{
  5. 		bool exchange = false;
  6. 		for (int i = 1; i < n - j; i++)
  7. 		{
  8. 			if (a[i - 1] > a[i])
  9. 			{
  10. 				int tmp = a[i];
  11. 				a[i] = a[i - 1];
  12. 				a[i - 1] = tmp;
  13.  
  14. 				exchange = true;
  15. 			}
  16. 		}
  17.  
  18. 		if (exchange == false)
  19. 		{
  20. 			break;
  21. 		}
  22. 	}
  23. }

冒泡排序使用了两个循环，外层循环控制排序的轮数，内层循环控制每轮排序的次数。每轮排序都会将未排序部分的最大值交换到未排序部分的最后面，因此每轮排序都会将未排序部分的长度减1

  • 代码中的变量 j 表示已排序部分的长度，初始值为0，每轮排序结束后 j 的值加1。
  • 内层循环从第一个元素开始，依次比较相邻的两个元素，如果它们的顺序错误就交换它们的位置。
  • 如果在一轮排序中没有发生任何交换，说明已经排好序了，可以直接退出循环。

特性

  1. 这个算法的时间复杂度是O(n^2)，因为它需要进行n轮排序，每轮排序需要比较n-j-1次相邻的元素，因此总共需要比较(n-1)+(n-2)+...+1=n*(n-1)/2次。 
  2. 空间复杂度：O(1)
  3. 稳定性：稳定

三、快速排序

快速排序是一种交换排序方法，由Hoare于1962年提出。它使用二叉树结构来进行排序，

基本思想：

  • 从待排序元素序列中任选一个元素作为基准值，按照该元素的排序码将待排序集合分割成两个子序列。
  • 左子序列中的所有元素都小于基准值，右子序列中的所有元素都大于基准值。
  • 然后，对左右子序列分别重复该过程，直到所有元素都排列在相应位置上为止。

 我们以数组第一个元素6为基准值key，通过动图来体会一下划分一次的过程。

 在每次分割过程中，选择一个基准值，将序列中的元素按照基准值的大小分割成两个子序列。然后，对这两个子序列分别进行递归排序，最终将它们合并起来，就可以得到一个有序的序列。

1、三种一次划分操作 

接下来我们对三种快排的方法进行讲解：

Hoare法

通过动图来体会一下Hoare法划分一次的过程。

  1. void Swap(int* p1, int* p2)
  2. {
  3. 	int tmp = *p1;
  4. 	*p1 = *p2;
  5. 	*p2 = tmp;
  6. }
  7.  
  8. int PartSort1(int* a, int left, int right)
  9. {
  10. 	int keyi = left;
  11. 	while (left < right) {
  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.  
  23. 	Swap(&a[keyi], &a[left]);
  24.     
  25.     return left;
  26. }

  1. 函数中使用了两个指针 left 和 right，它们分别指向区间的左右两端。
  2. 首先将基准值keyi赋值为left。

    代码首先判断left是否小于right，如果不是，则说明当前子序列已经比较完毕，可以退出循环。

    接着，代码判断a[right]是否大于等于a[keyi]，如果是，则说明a[right]比关键元素大或者相等，需要继续向左查找比关键元素小的元素。因此，right指针向左移动一位，继续比较下一个元素。

  3. 在内层循环中，首先从右侧开始，代码先判断left是否小于right，如果不是，则说明当前子序列已经比较完毕，可以退出循环。接着，代码判断a[right]是否大于等于a[keyi]，如果是，则说明a[right]比关键元素大或者相等，需要继续向左查找比关键元素小的元素。
  4. 如果找到第一个小于基准值 a[keyi] 的元素，从左侧开始，继续找到第一个大于基准值的元素。接着，交换这两个元素的位置，使得左侧元素小于等于基准值，右侧元素大于等于基准值。重复这个过程，直到 left 和 right 指针相遇。 
  5. 如果left和right相遇，则退出循环，将关键元素 a[keyi] 与 left 指针所指向的元素交换位置，使得基准值位于分区的中间位置。这样，分区函数 PartSort1 就完成了它的任务。
  6. 最后，交换a[keyi]和a[left]的值，返回基准值 a[keyi] 排序后的位置 left 。
  • 需要注意的是，函数 PartSort1 返回了 left 指针的值，这个值表示基准值在分区后的位置。在快速排序算法中，这个值会被用来确定下一次分区的区间范围。
  • 另外，函数中使用了一个 Swap 函数，用于交换两个指针所指向的元素的值。这个函数的作用是使代码更加简洁和易读，避免了重复的代码。

挖洞法

通过动图来体会一下挖洞法划分一次的过程。

  1. int PartSort2(int* a, int left, int right)
  2. {
  3. 	int key = a[left];
  4. 	int hole = left;
  5. 	while (left < right) {
  6. 		while (left < right && a[right] >= key) {
  7. 			right--;
  8. 		}
  9. 		a[hole] = a[right];
  10. 		hole = right;
  11. 		while (left < right && a[left] <= key) {
  12. 			left++;
  13. 		}
  14. 		a[hole] = a[left];
  15. 		hole = right;
  16. 	}
  17. 	a[hole] = key;
  18. 	return hole;
  19. }

  1. 首先，定义了一个名为PartSort2的函数，该函数接受三个参数：一个整型数组a，以及左右两个下标left和right，表示要排序的数组a的左右边界。
  2. 定义了一个名为key的变量，用于存储左边界位置的元素值，即a[left]的值。定义了一个名为hole的变量，用于记录当前空缺的位置，初始值为left。
  3. 进入while循环，当left小于right时，执行以下操作：
  4. 在循环中，先从右边开始找到第一个小于key的元素，将其下标赋值给right。将a[right]的值赋值给a[hole]，即将右边界位置的元素放到空缺的位置上。将hole的值更新为right，即将空缺位置的下标更新为右边界位置的下标。
  5. 接着，从左边开始找到第一个大于key的元素，将其下标赋值给left。将a[left]的值赋值给a[hole]，即将左边界位置的元素放到空缺的位置上。将hole的值更新为left，即将空缺位置的下标更新为左边界位置的下标。
  6. 循环结束后，将key的值赋值给a[hole]，即将key放到空缺的位置上。
  7. 最后，返回hole的值，即返回key在数组a中的位置。

前后指针法 

通过动图来体会一下前后指针法划分一次的过程。

 

 思路：

  1. 最开始prev和cur相邻的，
  2. 当cur遇到比key的大的值以后，cur移动prev不动，他们之间的值都是比key大的值
  3. cur找小，找到小的以后，跟prev位置的值交换，然后prev后移一位。
  4. 相当于把大翻滚式往右边推，同时把小的换到左边
  1. int PartSort3(int* a, int left, int right)
  2. {
  3. 	int prev = left;
  4. 	int cur = left + 1;
  5. 	int keyi = left;
  6. 	while (cur <= right){
  7. 		if (a[cur] < a[keyi] && ++prev != cur){
  8. 			Swap(&a[prev], &a[cur]);
  9. 		}
  10. 		++cur;
  11. 	}
  12. 	Swap(&a[prev], &a[keyi]);
  13. 	keyi = prev;
  14. 	return keyi;
  15. }

  1. 首先，定义了一个名为PartSort3的函数，该函数接受三个参数：一个整型数组a，以及左右两个下标left和right，表示要排序的数组a的左右边界。
  2. 定义了三个变量：prev、cur和keyi，分别表示当前处理的位置、当前遍历的位置和关键元素的位置，初始值均为left。
  3. 进入while循环，当cur小于等于right时，执行以下操作：
  4. 如果a[cur]小于a[keyi]，同时，prev等于cur，那么说明当前遍历到的元素就是小于基准的元素，不需要进行交换。如果prev不等于cur，那么说明在cur之前有大于基准的元素，需要将当前元素与a[prev]进行交换，以保证prev左边的元素都小于基准。并将a[prev]和a[cur]交换位置，即将小于关键元素的元素放到前面。
  5. 将cur的值加1，继续遍历数组。
  6. 循环结束后，将a[prev]和a[keyi]交换位置，即将关键元素放到正确的位置上。
  7. 将keyi的值更新为prev，即将关键元素的位置更新为当前的位置。
  8. 最后，返回keyi的值，即返回关键元素在数组a中的位置。

 三种方法总结： 

  • PartSort1函数：该函数采用的是左右指针法，即从左右两端开始遍历数组，将小于关键元素的元素放到左边，大于关键元素的元素放到右边，最后将关键元素放到正确的位置上。该函数的时间复杂度为O(nlogn)。

  • PartSort2函数：该函数采用的是挖坑填数法，即先将关键元素挖出来，然后从右边开始找到第一个小于关键元素的元素，将其放到左边的空位上，再从左边开始找到第一个大于关键元素的元素，将其放到右边的空位上，最后将关键元素放到正确的位置上。该函数的时间复杂度为O(nlogn)。

  • PartSort3函数：该函数采用的是前后指针法，即从左到右遍历数组，将小于关键元素的元素放到前面，大于关键元素的元素放到后面，最后将关键元素放到正确的位置上。该函数的时间复杂度为O(n)。

总体来说，这三种函数都是快速排序算法中的重要组成部分，它们的实现方式不同，但本质上都是通过将小于关键元素的元素放到前面，大于关键元素的元素放到后面，来实现对数组的排序。在实际应用中，可以根据具体情况选择不同的函数来实现快速排序算法。

2、改进划分效率 

但是这样每次都已区间最左位置的元素为基准值 ，可能会导致排序效率很低。

这是因为在某些情况下，选择的基准值可能会导致划分后的两个子序列长度差别很大，从而使得快速排序算法的时间复杂度退化为O(n^2)。

例如：如果待排序的数组已经是有序而且是升序的，而每次选择的基准值都是区间最左位置的元素，那么每次划分后的左子序列都为空，右子序列都包含了原数组中的所有元素，这样就会导致快速排序算法的时间复杂度退化为O(n^2)。

为了避免这种情况，可以采用一些优化策略，如三数取中法、随机化等。

  • 三数取中法是指在区间的左、中、右三个位置分别取出一个数，然后将它们排序，取中间值作为基准值。这样可以避免选择到极端值作为基准值，从而提高快速排序算法的效率。
  • 随机化则是指在待排序的数组中随机选择一个元素作为基准值，这样可以使得每次划分后的两个子序列长度差别更小，从而提高快速排序算法的效率。

实际中我们更推荐三数取中法，它的效率会更好一点。 

通过该代码实现找到区间中的中位数， 代码如下：

  1. int GetMidIndex(int* a, int left, int right)
  2. {
  3. 	int mid = (left + right) / 2;
  4. 	if (a[left] < a[mid])
  5. 	{
  6. 		if (a[mid] < a[right])
  7. 		{
  8. 			return mid;
  9. 		}
  10. 		else if (a[left] < a[right])
  11. 		{
  12. 			return right;
  13. 		}
  14. 		else
  15. 		{
  16. 			return left;
  17. 		}
  18. 	}
  19. 	else // a[left] > a[mid]
  20. 	{
  21. 		if (a[mid] > a[right])
  22. 		{
  23. 			return mid;
  24. 		}
  25. 		else if (a[left] > a[right])
  26. 		{
  27. 			return right;
  28. 		}
  29. 		else
  30. 		{
  31. 			return left;
  32. 		}
  33. 	}
  34. }

接下来将中位数运用到Hoare法函数PartSort3中：（挖洞和Hoare方法操作相同）

  1. int PartSort3(int* a, int left, int right)
  2. {
  3.     //获取中位数
  4. 	int midi = GetMidIndex(a, left, right);
  5. 	//将中位数的值与left交换
  6.     Swap(&a[left], &a[midi]);
  7.  
  8. 	int prev = left;
  9. 	int cur = left + 1;
  10. 	int keyi = left;
  11. 	while (cur <= right){
  12. 		if (a[cur] < a[keyi] && ++prev != cur){
  13. 			Swap(&a[prev], &a[cur]);
  14. 		}
  15. 		++cur;
  16. 	}
  17. 	Swap(&a[prev], &a[keyi]);
  18. 	keyi = prev;
  19. 	return keyi;
  20. }

 3、递归实现快速排序

 排序一个区间的函数PartSort1我们写完后，应该将它运用起来，通过递归思想对每个划分区间进行排序，从而实现快速排序。

  1. void QuickSort(int* a, int begin, int end)
  2. {
  3. 	if (begin >= end)
  4. 		return;
  5.  
  6. 	int keyi = PartSort1(a, begin, end);
  7. 	//每次划分范围 [begin, keyi-1] keyi [keyi+1, end]
  8.  
  9. 	QuickSort(a, begin, keyi - 1);
  10. 	QuickSort(a, keyi + 1, end);
  11. }
  1. QuickSort函数是快速排序算法的入口函数，它接受一个整型数组a、数组的起始下标begin和结束下标end作为参数。
  2. 在函数内部，首先判断递归结束条件—begin和end的大小关系，如果begin大于等于end，分别代表“区间不存在”和”区间只有一个值“，则直接结束当前递归，
  3. 否则调用PartSort1函数对数组进行一次划分操作，将数组a中的元素分为两部分，一部分小于等于a[keyi]，另一部分大于a[keyi]，并返回a[keyi]在排序后的位置。
  4. 然后，递归调用QuickSort函数对左半部分和右半部分进行排序，直到整个数组有序。

这个递归版本的快速排序算法。与非递归版本相比，它的实现更加简单，但是可能会因为递归调用的深度过大而导致栈溢出的问题。 

接下来我们来看看非递归如何实现快速排序： 

4、非递归实现快速排序

我们将待排序数组的起始位置和结束位置入栈，然后不断地从栈中取出两个位置，对这两个位置之间的元素进行分区操作，得到基准元素的位置，然后将基准元素左右两边的子数组的起始位置和结束位置入栈，以便后续处理。这样就可以避免递归调用带来的额外开销，提高了快速排序的效率。 

 栈的函数：

  1. #include<stdlib.h>
  2. #include<assert.h>
  3. #include<stdbool.h>
  4.  
  5. typedef int STDataType;
  6. typedef struct Stack
  7. {
  8. 	STDataType* a;
  9. 	int top;
  10. 	int capacity;
  11. }ST;
  12.  
  13. void STInit(ST* pst);
  14. void STDestroy(ST* pst);
  15. void STPush(ST* pst, STDataType x);
  16. void STPop(ST* pst);
  17. STDataType STTop(ST* pst);
  18. bool STEmpty(ST* pst);
  19. int STSize(ST* pst);
  20.  
  21. void STInit(ST* pst)
  22. {
  23. 	assert(pst);
  24. 	pst->a = NULL;
  25.  
  26. 	pst->top = 0;   
  27. 	pst->capacity = 0;
  28. }
  29.  
  30. void STDestroy(ST* pst)
  31. {
  32. 	assert(pst);
  33.  
  34. 	free(pst->a);
  35. 	pst->a = NULL;
  36. 	pst->top = pst->capacity = 0;
  37. }
  38.  
  39. void STPush(ST* pst, STDataType x)
  40. {
  41. 	if (pst->top == pst->capacity)
  42. 	{
  43. 		int newCapacity = pst->capacity == 0 ? 4 : pst->capacity * 2;
  44. 		STDataType* tmp = (STDataType*)realloc(pst->a, newCapacity * sizeof(STDataType));
  45. 		if (tmp == NULL)
  46. 		{
  47. 			perror("realloc fail");
  48. 			return;
  49. 		}
  50.  
  51. 		pst->a = tmp;
  52. 		pst->capacity = newCapacity;
  53. 	}
  54.  
  55. 	pst->a[pst->top] = x;
  56. 	pst->top++;
  57. }
  58.  
  59. void STPop(ST* pst)
  60. {
  61. 	assert(pst);
  62. 	assert(!STEmpty(pst));
  63.  
  64. 	pst->top--;
  65. }
  66.  
  67. STDataType STTop(ST* pst)
  68. {
  69. 	assert(pst);
  70. 	assert(!STEmpty(pst));
  71.  
  72. 	return pst->a[pst->top - 1];
  73. }
  74.  
  75. bool STEmpty(ST* pst)
  76. {
  77. 	assert(pst);
  78.  
  79. 	return pst->top == 0;
  80. }
  81.  
  82. int STSize(ST* pst)
  83. {
  84. 	assert(pst);
  85.  
  86. 	return pst->top;
  87. }

非递归排序函数：

  1. void QuickSortNonR(int* a, int begin, int end)
  2. {
  3. 	ST st;
  4. 	STInit(&st);
  5. 	STPush(&st, end);
  6. 	STPush(&st, begin);
  7.  
  8. 	while (!STEmpty(&st))
  9. 	{
  10. 		int left = STTop(&st);
  11. 		STPop(&st);
  12.  
  13. 		int right = STTop(&st);
  14. 		STPop(&st);
  15.  
  16. 		//PartSort3也可以，讲解基于PartSort1
  17.         //int keyi = PartSort3(a, left, right);
  18. 		int keyi = PartSort1(a, left, right);
  19.  
  20. 		if (keyi + 1 < right)
  21. 		{
  22. 			STPush(&st, right);
  23. 			STPush(&st, keyi + 1);
  24. 		}
  25.  
  26. 		if (left < keyi-1)
  27. 		{
  28. 			STPush(&st, keyi-1);
  29. 			STPush(&st, left);
  30. 		}
  31. 	}
  32.  
  33. 	STDestroy(&st);
  34. }

 下面是对left到key部分（即第一个基准值key的左部分）进行操作的过程： 

ST是一个栈的结构体，STInit、STPush、STPop和STEmpty分别是初始化栈、入栈、出栈和判断栈是否为空的函数。PartSort1是快速排序中的分区函数，用于将数组分成两个部分。具体来说，PartSort1函数选择数组的最后一个元素作为基准元素，然后将小于基准元素的元素放在数组的左边，大于基准元素的元素放在数组的右边，最后返回基准元素的位置。

  1. 初始化一个空栈，将待排序数组的开始和结束位置入栈。
  2. 进入一个循环，条件是栈不为空。在每次循环中：
  3. 从栈顶取出一个元素，作为当前子数组的开始位置，再从栈顶取出一个元素，作为当前子数组的结束位置。
  4. 调用PartSort1函数，对当前子数组进行一次快速排序的划分，返回划分元素的位置。这个函数的作用是找到一个元素（划分元素），使得它左边的所有元素都小于它，它右边的所有元素都大于它。
  5. 如果划分元素的右边还有元素（即keyi + 1 < right），则将右边子数组的开始和结束位置入栈。
  6. 如果划分元素的左边还有元素（即left < keyi-1），则将左边子数组的开始和结束位置入栈。
  7. 当栈为空时，所有子数组都已经排序完成，算法结束，销毁栈。

5、特性 

递归和非递归版本的快速排序算法的时间复杂度是一样的，都是在平均情况下O(n log n)，在最坏情况下O(n^2)。

这是因为每次划分都将数组分成了两个部分，每个部分的长度大约是原数组长度的一半，因此需要进行log n次划分才能完成排序。在每次划分中，需要遍历整个数组，时间复杂度是O(n)。因此，快速排序的平均时间复杂度是O(n log n)。 

空间复杂度：O(logN)
  • 快速排序的空间复杂度主要取决于递归调用的深度，也就是递归树的高度。
  • 在最好的情况下，每次分区都将数组分为两个大致相等的部分，那么递归树的高度为log n，所以空间复杂度为O(log n)。
  • 在最坏的情况下，每次分区只能将数组分为一个元素和其余元素两部分，那么递归树的高度为n，所以空间复杂度为O(n)。
  • 但是，通过一些优化策略，如随机化快速排序（每次随机选择基准元素）和尾递归优化（每次先处理较小的子数组），可以使得快速排序在实际应用中的空间复杂度接近O(log n)。
稳定性：不稳定

 完整代码：

 声明头文件：

  1. #include<stdio.h>
  2. #include<stdlib.h>
  3. #include<stdbool.h>
  4.  
  5. void PrintArray(int* a, int n);
  6. void BubbleSort(int* a, int n);
  7. void QuickSort(int* a, int begin, int end);
  8. void QuickSortNonR(int* a, int begin, int end);
  9.

 排序函数：

  1. #include "sort.h"
  2.  
  3. void PrintArray(int* a, int n)
  4. {
  5. 	for (int i = 0; i < n; i++) {
  6. 		printf("%d ", a[i]);
  7. 	}
  8. 	printf("\n");
  9. }
  10.  
  11. void BubbleSort(int* a, int n)
  12. {
  13. 	for (int j = 0; j < n; ++j)
  14. 	{
  15. 		bool exchange = false;
  16. 		for (int i = 1; i < n - j; i++)
  17. 		{
  18. 			if (a[i - 1] > a[i])
  19. 			{
  20. 				int tmp = a[i];
  21. 				a[i] = a[i - 1];
  22. 				a[i - 1] = tmp;
  23.  
  24. 				exchange = true;
  25. 			}
  26. 		}
  27.  
  28. 		if (exchange == false)
  29. 		{
  30. 			break;
  31. 		}
  32. 	}
  33. }
  34.  
  35. void Swap(int* p1, int* p2)
  36. {
  37. 	int tmp = *p1;
  38. 	*p1 = *p2;
  39. 	*p2 = tmp;
  40. }
  41.  
  42. int GetMidIndex(int* a, int left, int right)
  43. {
  44. 	int mid = (left + right) / 2;
  45. 	if (a[left] < a[mid]) {
  46. 		if (a[mid] < a[right]) {
  47. 			return mid;
  48. 		}
  49. 		else if (a[left] < a[right]) {
  50. 			return right;
  51. 		}
  52. 		else {
  53. 			return left;
  54. 		}
  55. 	}
  56. 	else {//a[left]>a[mid]
  57. 		if (a[mid] > a[right]) {
  58. 			return mid;
  59. 		}
  60. 		else if (a[left] < a[right]) {
  61. 			return left;
  62. 		}
  63. 		else {
  64. 			return right;
  65. 		}
  66. 	}
  67. }
  68.  
  69. // hoare
  70. // [left, right]
  71. int PartSort1(int* a, int left, int right)
  72. {
  73. 	int midi = GetMidIndex(a, left, right);
  74. 	Swap(&a[left], &a[midi]);
  75.  
  76. 	int keyi = left;
  77. 	while (left < right) {
  78. 		//右边找小
  79. 		while (left < right && a[right] >= a[keyi]) {
  80. 			right--;
  81. 		}
  82. 		while (left < right && a[left] <= a[keyi]) {
  83. 			left++;
  84. 		}
  85.  
  86. 		Swap(&a[left], &a[right]);
  87. 	}
  88.  
  89. 	Swap(&a[keyi], &a[left]);
  90.  
  91. 	return left;
  92. }
  93.  
  94. // 挖坑法
  95. // [left, right]
  96. int PartSort2(int* a, int left, int right)
  97. {
  98. 	int midi = GetMidIndex(a, left, right);
  99. 	Swap(&a[left], &a[midi]);
  100.  
  101. 	int key = a[left];
  102. 	int hole = left;
  103. 	while (left < right) {
  104. 		while (left < right && a[right] >= key) {
  105. 			right--;
  106. 		}
  107. 		a[hole] = a[right];
  108. 		hole = right;
  109. 		while (left < right && a[left] <= key) {
  110. 			left++;
  111. 		}
  112. 		a[hole] = a[left];
  113. 		hole = right;
  114. 	}
  115. 	a[hole] = key;
  116. 	return hole;
  117. }
  118.  
  119. // 前后指针法
  120. // [left, right]
  121. int PartSort3(int* a, int left, int right)
  122. {
  123. 	int midi = GetMidIndex(a, left, right);
  124. 	Swap(&a[left], &a[midi]);
  125.  
  126. 	int prev = left;
  127. 	int cur = left + 1;
  128. 	int keyi = left;
  129. 	while (cur <= right){
  130. 		if (a[cur] < a[keyi] && ++prev != cur){
  131. 			Swap(&a[prev], &a[cur]);
  132. 		}
  133. 		++cur;
  134. 	}
  135. 	Swap(&a[prev], &a[keyi]);
  136. 	keyi = prev;
  137. 	return keyi;
  138. }
  139.  
  140. // 时间复杂度: O(logN*N)
  141. // 空间复杂度：O(logN)
  142. void QuickSort(int* a, int begin, int end)
  143. {
  144. 	if (begin >= end)
  145. 		return;
  146.  
  147. 	int keyi = PartSort3(a, begin, end);
  148. 	// [begin, keyi-1] keyi [keyi+1, end]
  149.  
  150. 	QuickSort(a, begin, keyi - 1);
  151. 	QuickSort(a, keyi + 1, end);
  152. }
  153.  
  154. void QuickSortNonR(int* a, int begin, int end)
  155. {
  156. 	ST st;
  157. 	STInit(&st);
  158. 	STPush(&st, end);
  159. 	STPush(&st, begin);
  160.  
  161. 	while (!STEmpty(&st))
  162. 	{
  163. 		int left = STTop(&st);
  164. 		STPop(&st);
  165.  
  166. 		int right = STTop(&st);
  167. 		STPop(&st);
  168.  
  169. 		//int keyi = PartSort3(a, left, right);
  170. 		int keyi = PartSort1(a, left, right);
  171.  
  172. 		// [left, keyi-1] keyi [keyi+1, right]
  173.  
  174. 		if (keyi + 1 < right)
  175. 		{
  176. 			STPush(&st, right);
  177. 			STPush(&st, keyi + 1);
  178. 		}
  179.  
  180. 		if (left < keyi-1)
  181. 		{
  182. 			STPush(&st, keyi-1);
  183. 			STPush(&st, left);
  184. 		}
  185. 	}
  186.  
  187. 	STDestroy(&st);
  188. }

测试函数：

  1. #include"Sort.h"
  2. #include<time.h>
  3.  
  4. //测试排序
  5. void TestBubbleSort()
  6. {
  7. 	int a[] = { 4,7,1,9,3,6,5,8,3,2,0 };
  8. 	PrintArray(a, sizeof(a) / sizeof(int));
  9. 	BubbleSort(a, sizeof(a) / sizeof(int));
  10. 	PrintArray(a, sizeof(a) / sizeof(int));
  11. }
  12.  
  13. void TestQuickSort()
  14. {
  15. 	//int a[] = { 4,7,1,9,3,6,5,8,3,2,0 };
  16. 	int a[] = { 6,1,2,7,9,3,4,5,10,8 };
  17.  
  18. 	PrintArray(a, sizeof(a) / sizeof(int));
  19. 	//QuickSort(a, 0, sizeof(a) / sizeof(int)-1);
  20.     QuickSortNonR(a, 0, sizeof(a) / sizeof(int)-1);
  21. 	PrintArray(a, sizeof(a) / sizeof(int));
  22. }
  23.  
  24. //测试运行效率
  25. void TestOP()
  26. {
  27. 	srand(time(0));
  28. 	const int N = 1000000;
  29. 	int* a1 = (int*)malloc(sizeof(int) * N);
  30. 	int* a2 = (int*)malloc(sizeof(int) * N);
  31. 	int* a3 = (int*)malloc(sizeof(int) * N);
  32. 	int* a4 = (int*)malloc(sizeof(int) * N);
  33. 	int* a5 = (int*)malloc(sizeof(int) * N);
  34. 	int* a6 = (int*)malloc(sizeof(int) * N);
  35. 	int* a7 = (int*)malloc(sizeof(int) * N);
  36.  
  37.  
  38. 	for (int i = 0; i < N; ++i)
  39. 	{
  40. 		a1[i] = rand();
  41. 		a2[i] = a1[i];
  42. 		a3[i] = a1[i];
  43. 		a4[i] = a1[i];
  44. 		a5[i] = a1[i];
  45. 		a6[i] = a1[i];
  46. 		a7[i] = a1[i];
  47. 	}
  48.  
  49. 	int begin1 = clock();
  50. 	BubbleSort(a1, N);
  51. 	int end1 = clock();
  52.  
  53. 	int begin2 = clock();
  54. 	QuickSort(a2, 0, N - 1);
  55. 	int end2 = clock();
  56.  
  57. 	printf("BubbleSort:%d\n", end1 - begin1);
  58. 	printf("QuickSort:%d\n",  end2 - begin2);
  59.  
  60. 	free(a1);
  61. 	free(a2);
  62. 	free(a3);
  63. 	free(a4);
  64. 	free(a5);
  65. 	free(a6);
  66. 	free(a7);
  67. }
  68.  
  69. int main()
  70. {
  71. 	//TestBubbleSort();
  72.  
  73. 	//TestQuickSort();
  74.  
  75. 	//estOP();
  76.  
  77. 	return 0;
  78. }
  79.
声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/花生_TL007/article/detail/472518
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号