• 【数据结构---排序】很详细的哦

    本篇文章介绍数据结构中的几种排序哦~

    前言

      排序在我们的生活当中无处不在，当然，它在计算机程序当中也是一种很重要的操作，排序的主要目的是为了便于查找。

    一、排序是什么？

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

    二、排序的分类

    框架图：

    这里呢我们就介绍几种比较重要的排序算法。 

    1.直接插入排序

    扑克牌是我们几乎每个人都可能玩过的游戏吧，最基本的扑克玩法大多都是一边摸牌，一边理牌的。

    这里先看个动图吧，你是否看完动图就已经知道这种排序方式的思路了呢？

    动态图演示：

    思路：

     直接插入排序的思路呢就是每次将一个等待排序的元素与已经排序的元素进行一一比较，直到找到合适的位置按大小插入。它的基本操作就是将一个记录插入到已经排好序的有序表中，从而得到一个新的，记录数增1的有序表。

    代码如下：

    1. //插入排序
    2. #include
    3.  
    4. void PrintArray(int* a, int n)
    5. {
    6. 	for (int i = 0;i < n;i++)
    7. 	{
    8. 		printf("%d", a[i]);
    9. 	}
    10. 	printf("\n");
    11. }
    12. void InsertSort(int* a, int n)
    13. {
    14. 	for (int i = 0; i < n - 1; i++)
    15. 	{
    16. 		int end = i;
    17. 		int tmp = a[end + 1];
    18. 		while (end >= 0)
    19. 		{
    20. 			if (tmp < a[end])
    21. 			{
    22. 				a[end + 1] = a[end];
    23. 			}
    24. 			else
    25. 			{
    26. 				break;
    27. 			}
    28. 			--end;
    29. 		}
    30. 		a[end + 1] = tmp;
    31. 	}
    32. }
    33.  
    34. //测试
    35. void TestInsertSort()
    36. {
    37. 	int a[] = { 9,1,5,7,4,8,3 };
    38. 	InsertSort(a, sizeof(a) / sizeof(int));
    39. 	PrintArray(a, sizeof(a) / sizeof(int));
    40. }
    41. void TestOP()
    42. {
    43. 	srand(time(0));
    44. 	const int N = 10000;
    45. 	int* a1 = (int*)malloc(sizeof(int) * N);
    46. 	int* a2 = (int*)malloc(sizeof(int) * N);
    47. 	for (int i = N - 1;i >= 0;--i)
    48. 	{
    49. 		a1[i] = rand();
    50. 		a2[i] = a1[i];
    51. 	}
    52. 	int begin1 = clock();
    53. 	InsertSort(a1, N);
    54. 	int end1 = clock();
    55.     printf("InsertSort:%d\n", end1 - begin1);
    56.     free(a1);
    57. 	free(a2);
    58. }
    59. int main()
    60. {
    61. 	TestOP();
    62.     TestInsertSort();
    63. 	return 0;
    64. }

    执行结果：

    2.希尔排序（缩小增量排序）

    首先，给大家说明一下，希尔排序是D.L.Shell于1959年提出来的一种排序算法，在这之前呢，排序算法的时间复杂度大多基本都是O(n^2)的，而希尔排序算法可以说是突破这个时间复杂度的第一批算法之一了，换句话说，希尔排序算法的发明，使得我们终于突破了慢速排序的时代。之后，更为高效的排序算法也就相继出现了。

    有条件了很好，没条件我们去创造条件也是可以去做的，那么，在科学家希尔对直接插入排序进行打磨之后就可以增加效率了。一个问题的解决务必是因为该问题的诞生，那如何让待排序的记录个数变少呢？分割成若干个子序列，此时每个序列待排序的记录个数就比较少了，接着在这些子序列内分别进行直接插入排序，当整个序列都基本有序时，这里可要注意啦，是基本有序时，再次对全体记录进行一次直接插入排序。

    强调一下：这里的基本有序指的是小的关键字基本在前边，大的关键字基本在后边，不大不小的基本在中间。就和我们高中跑早操排队一样嘛，但是偶尔会出现一两对身高不太一样的好朋友往一块站对嘛。

    可是这里分割待排序记录的目的是减少待排序记录的个数，并且使整个序列向基本有序发展·，不过按照这样的方式好像并不能满足我们让分完组后就各自排序的这种要求哦，所以，我们需要采取的措施是：将相距某个“增量”的记录组成一个子序列，这样的话才能够保证在子序列内部分别进行直接插入排序后得到的结果是基本有序而不是局部有序的。

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

    代码如下：

    1. //希尔排序
    2. void PrintArray(int* a, int n)
    3. {
    4. 	for (int i = 0;i < n;i++)
    5. 	{
    6. 		printf("%d", a[i]);
    7. 	}
    8. 	printf("\n");
    9. }
    10.  
    11. void ShellSort(int* a, int n)
    12. {
    13. 	int gap = n;
    14. 	while (gap > 1)
    15. 	{
    16. 		gap = gap / 3 + 1;
    17. 		for (int i = 0; i < n - gap; ++i)
    18. 		{
    19. 			int end = i;
    20. 			int tmp = a[end + gap];
    21. 			while (end >= 0)
    22. 			{
    23. 				if (tmp < a[end])
    24. 				{
    25. 					a[end + gap] = a[end];
    26. 					end = end - gap;
    27. 				}
    28. 				else
    29. 				{
    30. 					break;
    31. 				}
    32. 			}
    33. 			a[end + gap] = tmp;
    34. 		}
    35. 	}
    36. }
    37. //测试
    38. void TestShellSort()
    39. {
    40. 	int a[] = { 9,1,5,7,4,8,3 };
    41. 	ShellSort(a, sizeof(a) / sizeof(int));
    42. 	PrintArray(a, sizeof(a) / sizeof(int));
    43. }
    44. void TestOP()
    45. {
    46. 	srand(time(0));
    47. 	const int N = 10000;
    48. 	int* a1 = (int*)malloc(sizeof(int) * N);
    49. 	int* a2 = (int*)malloc(sizeof(int) * N);
    50. 	for (int i = N - 1;i >= 0;--i)
    51. 	{
    52. 		a1[i] = rand();
    53. 		a2[i] = a1[i];
    54. 	}
    55. 	int begin1 = clock();
    56. 	ShellSort(a1, N);
    57. 	int end1 = clock();
    58.  
    59. 	printf("ShellSort:%d\n", end1 - begin1);
    60.  
    61. 	free(a1);
    62. 	free(a2);
    63. }
    64. int main()
    65. {
    66. 	TestOP();
    67. 	TestShellSort();
    68.  
    69. 	return 0;
    70. }
    71.

    执行结果;

    希尔排序的特性总结：

    （1）当gap > 1时其实都是预排序，目的是让数组更接近于有序。

             当gap == 1 时，其实就是直接插入排序，数组已经接近有序了，这样就会很快。就整体而言，可以达到优化的效果。

    （2）希尔排序的时间复杂度不是很好计算，因为gap的取值方法很多，导致很难去计算。

    说明：gap的取法有很多种，Shell提出取 gap = n / 2, gap = gap / 2,直到gap为1；

              后来，Knuth提出取gap = (gap / 3) + 1。

    无论哪一种，都没有得到证明！ ！ ！

    注：在Knuth所著的《计算机程序设计技巧》第三卷中，利用大量的实验统计资料得出，当n很大时，关键码平均比较次数和对象平均移动次数在n^1.25~1.6*n^1.25范围内，这是在利用直接插入排序作为子序列排序方法的情况下得到的。 

     3.选择排序

    动态图演示：

    看完图有没有思路呢？其实选择排序的思路蛮简单的，就是每一次从待排序的数据元素中选出最小/最大的一个元素，存放在序列的起始位置，直到全部待排序的数据元素排完。这种排序也就是通过n-i次关键字间的比较，从n - i + 1个记录中选出关键字最小的记录，并且和第 i (1 <= i <= n)个记录交换。

    代码如下：

    1.  
    2.  //选择排序
    3. void PrintArray(int* a, int n)
    4. {
    5. 	for (int i = 0; i < n; i++)
    6. 	{
    7. 		printf("%d ", a[i]);
    8. 	}
    9. 	printf("\n");
    10. }
    11.  
    12. void Swap(int* x, int* y)
    13. {
    14. 	int tmp = *x;
    15. 	*x = *y;
    16. 	*y = tmp;
    17. }
    18.  
    19. void SelectSort(int* a, int n)
    20. {
    21. 	int begin = 0, end = n - 1;
    22.  
    23. 	while (begin < end)
    24. 	{
    25. 		int mini = begin, maxi = begin;
    26. 		for (int i = begin + 1; i <= end; i++)
    27. 		{
    28. 			if (a[i] > a[maxi])
    29. 			{
    30. 				maxi = i;
    31. 			}
    32.  
    33. 			if (a[i] < a[mini])
    34. 			{
    35. 				mini = i;
    36. 			}
    37. 		}
    38.  
    39. 		Swap(&a[begin], &a[mini]);
    40. 		if (maxi == begin)
    41. 		{
    42. 			maxi = mini;
    43. 		}
    44.  
    45. 		Swap(&a[end], &a[maxi]);
    46.  
    47. 		++begin;
    48. 		--end;
    49. 	}
    50. }
    51.  
    52. //测试
    53. void TestSelectSort()
    54. {
    55. 	int a[] = { 9,1,5,7,4,8,3 };
    56. 	SelectSort(a, sizeof(a) / sizeof(int));
    57. 	PrintArray(a, sizeof(a) / sizeof(int));
    58. }
    59.  
    60. void TestOP()
    61. {
    62. 	srand(time(0));
    63. 	const int N = 100;
    64. 	int* a1 = (int*)malloc(sizeof(int) * N);
    65. 	int* a2 = (int*)malloc(sizeof(int) * N);
    66. 	for (int i = N - 1; i >= 0; --i)
    67. 	{
    68. 		a1[i] = rand();
    69. 		a2[i] = a1[i];
    70. 	}
    71. 	int begin1 = clock();
    72. 	SelectSort(a1, N);
    73. 	int end1 = clock();
    74.  
    75. 	printf("SelectSort:%d\n", end1 - begin1);
    76.  
    77. 	free(a1);
    78. 	free(a2);
    79. }
    80. int main()
    81. {
    82. 	TestOP();
    83. 	TestSelectSort();
    84.  
    85. 	return 0;
    86. }

    执行结果：

     从选择排序的过程来看，它最大的特点就是交换移动数据次数相对较少，这样也就节约了相应的时间。

    总结：选择排序它的思路很好理解，但是其效率并不是很好，很少用到。

    4.冒泡排序

    无论你学习哪种编程语言，在学到循环和数组的时候，通常都会介绍一种排序算法，而这个算法一般就是冒泡排序。并不是说它的名字好听，而是说这个算法的思路最简单，最容易理解哦。

    冒泡排序呢我们可以理解为一种交换排序，其基本思想是：对数组进行遍历，每次对相邻两个进行比较大小，如果大的数值在前面，那么交换位置也可以理解为升序，完成一趟遍历后数组中最大的数值到了数组的末尾位置，再对前面n-1个数值进行相同的遍历，一共完成n-1次遍历就实现了排序完成。

    动态图演示：

    代码如下：

    1. //冒泡排序
    2. void PrintArray(int* a, int n)
    3. {
    4. 	for (int i = 0;i < n;i++)
    5. 	{
    6. 		printf("%d", a[i]);
    7. 	}
    8. 	printf("\n");
    9. }
    10. void Swap(int* x, int* y)
    11. {
    12. 	int tmp = *x;
    13. 	*x = *y;
    14. 	*y = tmp;
    15. }
    16. void BubbleSort(int* a, int n)
    17. {
    18. 	for (int j = 0; j < n; j++)
    19. 	{
    20. 		int exchange = 0;
    21. 		for (int i = 1; i < n - j; i++)
    22. 		{
    23. 			if (a[i - 1] > a[i])
    24. 			{
    25. 				Swap(&a[i - 1], &a[i]);
    26. 				exchange = 1;
    27. 			}
    28. 		}
    29.  
    30. 		if (exchange == 0)
    31. 		{
    32. 			break;
    33. 		}
    34. 	}
    35. }
    36.  
    37. //测试
    38. void TestBubbleSort()
    39. {
    40. 	int a[] = { 9,1,5,7,4,8,3 };
    41. 	BubbleSort(a, sizeof(a) / sizeof(int));
    42. 	PrintArray(a, sizeof(a) / sizeof(int));
    43. }
    44. void TestOP()
    45. {
    46. 	srand(time(0));
    47. 	const int N = 100;
    48. 	int* a1 = (int*)malloc(sizeof(int) * N);
    49. 	int* a2 = (int*)malloc(sizeof(int) * N);
    50. 	for (int i = N - 1; i >= 0; --i)
    51. 	{
    52. 		a1[i] = rand();
    53. 		a2[i] = a1[i];
    54. 	}
    55. 	int begin1 = clock();
    56. 	BubbleSort(a1, N);
    57. 	int end1 = clock();
    58.  
    59. 	printf("BubbleSort:%d\n", end1 - begin1);
    60.  
    61. 	free(a1);
    62. 	free(a2);
    63. }
    64. int main()
    65. {
    66. 	TestOP();
    67. 	TestBubbleSort();
    68.  
    69. 	return 0;
    70. }

    执行结果：

    在这里呢简单提一下冒泡排序的效率，冒泡排序是稳定的排序算法，在相同数据排序时不会影响原来的顺序，对结构体类型有影响的。它的时间复杂度是O(n^2),空间复杂度是O(1)。 

     5.快速排序

      终于，我们的高手就要出场啦！假如说未来你在工作后，你的老板让你写个排序算法，而你会的算法中竟然没有快速排序，那么我建议你还是火速把快速排序算法找来敲入你排序算法的大队伍中吧，哈哈哈哈……

       简单介绍一下快速排序吧，快速排序算法最早是由图灵奖获得者Tony Hoare设计出来的。他在形式化方法理论以及ALGOL60编程语言的发明中都有卓越的贡献，是上世纪最伟大的计算机科学家之一。而这快速排序算法只是他众多贡献中小小的一个发明而已。你们知道吗，我们接下来要学习的这个快速排序算法可是被列为20世纪十大算法之一的哦~

     这段话大家好好看看哦~

    希尔排序可以说是直接插入排序的升级，都属于插入排序这一大类哦；

    快速排序可以说是冒泡排序的升级，都属于交换排序这一大类哦。也就是通过不断比较和移动交换来实现排序，不过它的实现相较其他而言，就是增大了记录的比较和移动的距离，将关键字大的记录从前面直接移动到后面去，关键字较小的记录从后面直接移动到前面，从而减少了总的比较次数和移动交换次数。

      基本思想：任取待排序元素序列中的某个元素作为基准值，按照该排序码将待排序码集合分割成两个子序列，左子序列中所有元素均小于基准值，右子序列中所有元素均大于基准值，然后最左右子序列重复该过程，直到所有元素都排列在相应位置上为止。

    在这里呢，我们主要对hoare排序以及对其的几种优化进行介绍：

    （1）hoare版本

    hoare版本是快速排序最原始的情况，（看看单趟的过程）

    这里单趟的目的是：要求左边的key要小，右边的key要大

    动态图演示：

    看完图，是否稍微有一点点思路呢？因为快速排序在排序中很重要，所以这里可能会说的详细一点，大家不要嫌我啰嗦哦~

    思路:

    a:先记录下keyi的位置，接着 left 和 right 分别从数组两端开始往中间走；

    b:当right先开始向中间行动，如果right处的值小于keyi处所对应的值，则停止等待left走；

    c:此时left开始行动，当left找到比keyi处小的值的时候，left 和 right处的值进行交换；

    d:当两个位置相遇时，将两个相遇位置的值与keyi处所对应的值进行交换，并且将相遇的位置记为新的keyi；

     代码如下：

    1. //这里出现了一种三数取中的方法，这样的话快速排序就不会出现最坏情况
    2. // 三数取中
    3.  
    4. void PrintArray(int* a, int n)
    5. {
    6. 	for (int i = 0;i < n;i++)
    7. 	{
    8. 		printf("%d", a[i]);
    9. 	}
    10. 	printf("\n");
    11. }
    12. void Swap(int* x, int* y)
    13. {
    14. 	int tmp = *x;
    15. 	*x = *y;
    16. 	*y = tmp;
    17. }
    18. int GetMidi(int* a, int left, int right)
    19. {
    20. 	int mid = (left + right) / 2;
    21. 	// left mid right
    22. 	if (a[left] < a[mid])
    23. 	{
    24. 		if (a[mid] < a[right])
    25. 		{
    26. 			return mid;
    27. 		}
    28. 		else if (a[left] > a[right])  // mid是最大值
    29. 		{
    30. 			return left;
    31. 		}
    32. 		else
    33. 		{
    34. 			return right;
    35. 		}
    36. 	}
    37. 	else // a[left] > a[mid]
    38. 	{
    39. 		if (a[mid] > a[right])
    40. 		{
    41. 			return mid;
    42. 		}
    43. 		else if (a[left] < a[right]) // mid是最小
    44. 		{
    45. 			return left;
    46. 		}
    47. 		else
    48. 		{
    49. 			return right;
    50. 		}
    51. 	}
    52. }

    1. //快速排序hoare版本
    2. int PartSort1(int* a, int left, int right)
    3. {
    4. 	int keyi = left;
    5. 	while (left < right)
    6. 	{
    7. 		//找小
    8. 		while (left < right && a[right] >= a[keyi])
    9. 		{
    10. 			--right;
    11. 		}
    12. 		//找大
    13. 		while (left < right && a[left] <= a[keyi])
    14. 		{
    15. 			++left;
    16. 		}
    17. 		Swap(&a[left], &a[right]);
    18. 	}
    19. 	Swap(&a[keyi], &a[left]);
    20. 	return left;
    21. };
    22. void QuickSort(int* a, int left, int right)
    23. {
    24. 	if (left >= right)
    25. 		return;
    26. 	if ((right - left + 1) > 10)
    27. 	{
    28. 		int keyi = PartSort1(a, left, right);
    29.  
    30. 		QuickSort(a, left, keyi - 1);
    31. 		QuickSort(a, keyi + 1, right);
    32. 	}
    33. 	else
    34. 	{
    35. 		InsertSort(a + left, right - left + 1);
    36. 	}
    37. }

    执行结果：

    （2）挖坑法版本

    动态图演示：

    看完图，有什么想法吗，或许有些同学对快速排序的第一个原始版本中，左边设置为keyi之后，右边就要先走是不太能理解的吧，这里就有脑洞大开的大佬想出了另外一种快速排序的方法，可能思路不太一样，不过相比而言，对我们这些小白来说更容易理解哦~ 

    思路：

    a:首先将begin处的值放到key中，然后将其设置为坑位，接着right抗下任务开始行动找值从而补坑；

    b:right找到比key小的值后将这个值放到刚才的坑位中，然后将这个新的位置重新设置为坑位；

    c:此时left也开始找值来进行补坑啦，找到比key大的值，然后将这个值放到坑位中，接着将这个新的位置重新设置为坑位；

    d:当left与right碰面时，再将key放入到坑位中；

    代码如下：

    1. //三数取中那一部分在前面哦！
    2. //挖坑法
    3.  
    4. int PartSort2(int* a, int left, int right)
    5. {
    6. 	int midi = GetMidi(a, left, right);
    7. 	Swap(&a[left], &a[midi]);
    8.  
    9. 	int key = a[left];
    10. 	// 保存key值以后，左边形成第一个坑
    11. 	int hole = left;
    12.  
    13. 	while (left < right)
    14. 	{
    15. 		// 右边先走，找小，填到左边的坑，右边形成新的坑位
    16. 		while (left < right && a[right] >= key)
    17. 		{
    18. 			--right;
    19. 		}
    20. 		a[hole] = a[right];
    21. 		hole = right;
    22.  
    23. 		// 左边再走，找大，填到右边的坑，左边形成新的坑位
    24. 		while (left < right && a[left] <= key)
    25. 		{
    26. 			++left;
    27. 		}
    28. 		a[hole] = a[left];
    29. 		hole = left;
    30. 	}
    31.  
    32. 	a[hole] = key;
    33. 	return hole；
    34. }
    35. void QuickSort(int* a, int begin, int end)
    36. {
    37. 	if (begin >= end)
    38. 		return;
    39.  
    40. 	int keyi = PartSort2(a, begin, end);
    41. 	// [begin, keyi-1] keyi [keyi+1, end]
    42. 	QuickSort(a, begin, keyi - 1);
    43. 	QuickSort(a, keyi + 1, end);
    44. }

     执行结果：

    （3）前后指针法版本

    动态图演示：

    这里呢，前后指针法与前面两种版本相比的话，无论是从哪个方面考虑都是有很大的提升的，也是一种很常见的写法。

    思路：

    a:cur位于begin+1的位置，prev位于begin的位置，keyi先存放begin处的值；

    b:cur不断往前+1，直到cur大于等于end时停止循环；

    c:如果cur处的值小于key处的值，而且prev+1不等于cur，那么与prev处的值进行交换；

    d:当循环结束时，将prev处的值与keyi处的值进行交换，而且将其置为新的keyi值 

     代码如下：

    1.  //前后指针
    2. int PartSort3(int* a, int left, int right)
    3. {
    4. 	int midi = GetMidi(a, left, right);
    5. 	Swap(&a[left], &a[midi]);
    6.  
    7. 	int prev = left;
    8. 	int cur = prev + 1;
    9.  
    10. 	int keyi = left;
    11. 	while (cur <= right)
    12. 	{
    13. 		if (a[cur] < a[keyi] && ++prev != cur)
    14. 		{
    15. 			Swap(&a[prev], &a[cur]);
    16. 		}
    17.  
    18. 		++cur;
    19. 	}
    20.  
    21. 	Swap(&a[prev], &a[keyi]);
    22. 	return prev;
    23. }
    24.  
    25. // [begin, end]
    26. void QuickSort(int* a, int begin, int end)
    27. {
    28. 	if (begin >= end)
    29. 		return;
    30.  
    31. 	int keyi = PartSort3(a, begin, end);
    32. 	// [begin, keyi-1] keyi [keyi+1, end]
    33. 	QuickSort(a, begin, keyi - 1);
    34. 	QuickSort(a, keyi + 1, end);
    35. }

    执行结果：

    说明：

      这里，在遍历的整个过程中，cur是不断向前的，只是cur处的值小于keyi处的值时才进行交换，使其进行判断；在cur位置处的值小于keyi处的值时，需要进行判断prev++是否等于cur，如果等于的话，则会出现自己交换自己的情形，当然，如果相等的话不用进行交换哦~ 

    1. //这是上面三种情况的测试代码
    2. void TestQuickSort()
    3. {
    4. 	int a[] = { 9,1,5,7,4,8,3 };
    5. 	QuickSort(a,0, sizeof(a) / sizeof(int)-1);
    6. 	PrintArray(a, sizeof(a) / sizeof(int));
    7. }
    8.  
    9. void TestOP()
    10. {
    11. 	srand((unsigned)time(0));
    12. 	const int N = 1000000;
    13. 	int* a1 = (int*)malloc(sizeof(int) * N);
    14. 	int* a2 = (int*)malloc(sizeof(int) * N);
    15. 	for (int i = N - 1; i >= 0; --i)
    16. 	{
    17. 		a1[i] = rand();
    18. 		a2[i] = a1[i];
    19. 	}
    20. 	int begin1 = clock();
    21. 	QuickSort(a1, 0, N-1);
    22. 	int end1 = clock();
    23.  
    24. 	printf("QuickSort:%d\n", end1 - begin1);
    25.  
    26. 	free(a1);
    27. 	free(a2);
    28. }
    29. int main()
    30. {
    31. 	TestOP();
    32. 	TestQuickSort();
    33.  
    34. 	return 0;
    35. }

    6.归并排序

      归并排序，归并归并，从字面意思来看，我们就可以有着把两个合并到一起的感觉。在数据结构中的定义呢是将两个或两个以上的有序表组合成一个新的有序表。

      我想问一下大家知道我们高考完那个所谓的一本，二本，还有专科线是怎么划分出来的吗，简而言之，假设各个高校的本科专业要在甘肃省高三学理科的学生中打算招收一万名学生，那么将全省参加高考的理科生进行一个倒排序，那么，这位排名在一万名的这位幸运同学的分数就会是本科线。换个思路想，如果你是年级第一，但你的分数没有高于这个分数线，那么很遗憾，你也就失去了上本科的机会。换言之，所谓的排名，其实也就是这个省份中的每个市一直到每个县城的每个学校的每个班级的排名合并之后，从而得到的。

    为了让大家更清楚的理解思路，这里给大家看个动态图吧~

    动态图演示：

    看完动态图，有没有稍微理解一点呢，话说回来，这就是我们要说的归并排序。 

    归并排序用到了分治的思想，借助递归的方式对一串数字进行排序，整个过程分为分开和合并这两个过程，其实，这里的思想也没有那么难理解，就是在代码实现的过程中我们需要写两个函数分别实现分开合并以及每一次排序的这个过程。

    通过上面的动图演示，我们不难发现，首先是要将整个待排序的数逐步分成小块，然后再进行归并。

    思路：

      归并排序的思路就是对于左右子区间都有序的序列，通过借助一个临时数组进行归并。

    然后定义两个指针begin1和begin2，分别指向两个子区间的头部，另外定义两个指针end1和end2,分别指向两个子区间的尾部。然后依次挨个比较begin1和begin2指向的值，将小的放入下面的临时数组中，直到其中的一个区间遍历完成后，我们就停下来，然后接着将没有走完的那个区间剩下的值直接拷贝给新数组。

    看到这的时候，我们应该能知道，当区间里只有1个数的时候，那么我们就可以理解为有序了，也就是可以进行归并操作了。所以，当左右这两个子区间都没有序的时候，我们就分治递归，不断的分割区间，直到区间分割到只剩下1个数的时候，此时，我们就进行归并啦~ 

    代码实现：

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

      我们常说，没有最好，只有更好。虽然说归并排序大量引用了递归，尽管在代码上是比较清晰的，可以使我们容易理解，但是这会造成时间和空间上的性能损耗，我们排序追求的不就是效率吗，有没有可能将递归转化为迭代呢？当然可以，而且改进之后，性能上可是进一步提高了哦~

    前面提到的是归并排序的递归思想，那接下来就说一下归并排序的非递归是怎么样的。

    思路：

    a:申请空间，使它的大小为两个已经排序的序列的和，然后该空间用来存放合并后的序列；

    b：设定两个指针，最开始的两个位置分别为两个已经排序的序列的起始位置；

    c:比较两个指针所指向的元素，选择相对小的元素放入到合并的空间中，并且移动指针到下一个位置；

    d:对上一步的步骤进行重复，直到某一指针超出序列尾部将另一个序列剩下的所有元素怒直接复制到合并的序列尾部。

    代码实现： 

    1. //sort.c
    2. void TestMergeNonRSort()
    3. {
    4. 	int a[] = { 9,1,2,5,7,4,3,9,3,1,2 };
    5.     MergeSortNonR(a, sizeof(a) / sizeof(int));
    6. 	PrintArray(a, sizeof(a) / sizeof(int));
    7. }
    8.  
    9. void TestOP()
    10. {
    11. 	srand(time(0));
    12. 	const int N = 10000000;
    13. 	int* a1 = (int*)malloc(sizeof(int) * N);
    14. 	int* a2 = (int*)malloc(sizeof(int) * N);
    15.  
    16. 	for (int i = N - 1; i >= 0; --i)
    17. 	{
    18. 		a1[i] = rand() + i;
    19. 		a2[i] = a1[i];
    20. 	}
    21.  
    22. 	int begin1 = clock();
    23. 	MergeSortNonR(a1, N);
    24. 	int end1 = clock();
    25.  
    26. 	printf("MergeSortNonR:%d\n", end1 - begin1);
    27.  
    28. 	free(a1);
    29. 	free(a2);
    30. }
    31.  
    32. int main()
    33. {
    34. 	//TestOP();
    35. 	TestMergeNonRSort();
    36.  
    37. 	return 0;
    38. }

       说明：非递归的方法，虽然说不是很好理解，也有点难，但是其避免了递归时深度为log2n的栈空间，并且避免递归也在时间性能上有一定的提升，可以说，使用归并排序时，尽可能考虑用非递归的方法。 

    7.计数排序

    这里要说的计数排序呢，它的原理就是通过遍历数组，记录每一个数字出现的次数，最终在新数组中体现出来，那么是如何实现的呢？

    思路：

    a:首先我们先遍历整个数组，找到数组中数值最大的数字max,并且申请max+1个桶（随便起的名字哈）来存储每个数字出现的次数，此时用下表记录；

    b:然后我们遍历原来的数组，找到每个数字对应的桶号，并且计数；

    c:遍历桶数组，看对应的桶内计数是多少，那么就取出几个下标值，放到原数组中。

     代码实现：

    1. //sort.c
    2. //计数排序
    3. void CountSort(int* a, int n)
    4. {
    5. 	int min = a[0], max = a[0];
    6. 	for (int i = 0; i < n; i++)
    7. 	{
    8. 		if (a[i] < min)
    9. 			min = a[i];
    10. 		if (a[i] > max)
    11. 			max = a[i];
    12. 	}
    13. 		int range = max - min + 1;
    14. 		int* count = (int*)malloc(sizeof(int) * range);
    15. 		printf("range:%d\n",range);
    16. 		if (count == NULL)
    17. 		{
    18. 			perror("malloc fail");
    19. 			return;
    20. 		}
    21. 		memset(count, 0, sizeof(int) * range);
    22.  
    23. 		for (int i = 0; i < n; i++)
    24. 		{
    25. 			count[a[i] - min]++;
    26. 		}
    27. 		//排序
    28. 		int j = 0;
    29. 		for (int i = 0;i < range;i++)
    30. 		{
    31. 			while (count[i]--)
    32. 			{
    33. 				a[j++] = i + min;
    34. 			}
    35. 		}
    36. }

    运行结果和前面的一样，就不贴出来啦，大家主要要体会每种排序的精髓在哪，完全理解它的思路，要领，核心还有它之所以叫这个排序，是为什么，到底哪里和其他的排序方式有差别，我想，如果大家报着这个态度去学习每一种排序，那数据结构中的几种排序不得被你狠狠拿捏了……

    总结

    这里呢，就对几种排序的时间复杂度，空间复杂度进行一个简单的总结哦~

    图片贴到这里啦，大家格外要理解稳定性不稳的几种排序的理由哦~

    好啦，关于数据结构中几种常见排序就先介绍到这里啦，如果哪里出错了，欢迎大家留言和我一起进步嘞。

  • 相关阅读:
    零基础学 Java 编程需要注意哪些事项？
    java计算机毕业设计高校医务管理系统源程序+mysql+系统+lw文档+远程调试
    这13个不经意却很不卫生的行为，很多人都没意识到
    LSS，2D-＞3D，Lift-Splat-Shoot:通过隐式反投影到3D空间实现对任意相机图像编码
    第10章_索引优化与查询优化
    别再用 hao123 360等垃圾导航了，这款主页插件让你浏览器首页高效简洁，高清好看
    Kettle安装初始化问题
    算法基础-----【动态规划】
    EasyExcel实现文件上传-批量插入 文件下载
    关于响应式编程ReactiveX，RxGo
  • 原文地址：https://blog.csdn.net/yyzzzj0301/article/details/131766361