devbox
秋刀鱼在做梦
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

常见排序算法详解（插入、希尔、选择、堆、冒泡、快速、归并）【C语言实现】_c语言简单选择排序递归

作者：秋刀鱼在做梦 | 2024-06-19 15:06:33

赞

踩

c语言简单选择排序递归

本文介绍和实现常见排序算法，其中对详细介绍快速排序和归并排序递归与非递归版本的实现。

目录

一、插入排序

1.基本思想

2.直接插入排序

3.希尔排序

二、选择排序

1.基本思想

2.直接选择排序

3.堆排序

三、交换排序

1.基本思想：

2.冒泡排序

3.快速排序（递归实现）

1.hoare版本

 2.挖坑版本

3.前后指针版本

4.快速排序优化

1.三数取中

2.小区间优化

5.快速排序（非递归实现）

四、归并排序

 1.递归实现

2.非递归实现

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. void InsertSort(int* a, int n)
  2. {			  //数组指针   元素个数
  3. 	for (int i = 0; i < n - 1; i++)
  4. 	{
  5. 		int end = i;//记录有序序列最后一个元素的下标
  6.  
  7. 		int tmp = a[end + 1];//待插入排序的元素
  8.  
  9. 		while (end >= 0)//寻找插入元素在有序数组中的位置的下标
  10. 		{
  11. 			if (a[end] > tmp)//如果插入元素小于当前比较元素（排升序）
  12. 			{
  13. 				a[end + 1] = a[end];//大的元素向后移动一位
  14. 				end--;
  15. 			}
  16. 			else
  17. 			{
  18. 				break;
  19. 			}
  20. 		}
  21. 		a[end + 1] = tmp;
  22. 	}
  23. }

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

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

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

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

4. 稳定性：稳定

（排序后不会打乱相同数据在数组中前后位置，则为稳定，希尔排序图解中标记）

3.希尔排序

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

希尔排序法的基本思想：

1.先选定一个小于N的整数gap作为第一增量，然后将所有距离为gap的元素分在同一组，并对每一组的元素进行直接插入排序。然后再取一个比第一增量小的整数作为第二增量，重复上述操作…

2.当增量的大小减到1时，就相当于整个序列被分到一组，进行一次直接插入排序，排序完成。

当gap越大时，数据挪动的越快，可以让数据快速到达所对应的位置附近。

下图以排升序为例：（gap每次除2）

 第一趟：gap = 5，分为5组元素，每组两个，对每一组进行插入排序

 第二趟：gap =  2，分为两组，每组5个元素，对每一组进行插入排序

 第二趟：gap =  1，分为1组，进行插入排序

 代码：

  1. void ShellSort(int* a, int n)
  2. {
  3. 	int gap = n;
  4. 	while (gap > 1)
  5. 	{
  6. 		gap = gap / 3 + 1;//当gap除以的数大于2时，+1避免出现gap/3=0的情况
  7. 		//对每组进行插入排序
  8. 		for (int i = 0; i < n - gap; i++)
  9. 		{
  10. 			int end = i;
  11. 			int tmp = a[end + gap];
  12. 			while (end >= 0)
  13. 			{
  14. 				if (tmp < a[end])
  15. 				{
  16. 					a[end + gap] = a[end];
  17. 					end -= gap;
  18. 				}
  19. 				else
  20. 				{
  21. 					break;
  22. 				}
  23. 			}
  24. 			a[end + gap] = tmp;
  25. 		}
  26. 	}	
  27. }

希尔排序的特性总结：

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

2. 当gap > 1时都是预排序，目的是让数组更接近于有序。当gap == 1时，数组已经接近有序的了，这样就会很快。这样整体而言，可以达到优化的效果。

3. 希尔排序的时间复杂度不好计算，因为gap的取值方法很多，导致很难去计算，暂且按照O(N*logN)。

4.空间复杂度：O( 1 )。

5.稳定性：不稳定（如上图中演示中：带下划线的5经过排序后被移动到了不带下划线的5的前面）

二、选择排序

1.基本思想

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

2.直接选择排序

1.在元素集合array[i]--array[n-1]中选择关键码最大(小)的数据元素。

2.若它不是这组元素中的最后一个(第一个)元素，则将它与这组元素中的最后一个（第一个）元素交换。

3.在剩余的array[i]--array[n-2]（array[i+1]--array[n-1]）集合中，重复上述步骤，直到集合剩余1个元素

动图演示：

在这里插入图片描述

代码：

  1. void Swap(int* a, int* b)
  2. {
  3. 	int tmp = *a;
  4. 	*a = *b;
  5. 	*b = tmp;
  6. }
  7. void SelectSort(int* a, int n)
  8. {
  9. 	for (int i = 0; i < n; i++)
  10. 	{
  11. 		int begin = i;
  12. 		int min = begin;
  13. 		while (begin < n)//遍历数组寻找最小的元素
  14. 		{
  15. 			if (a[begin] < a[min])
  16. 			{
  17. 				min = begin;
  18. 			}
  19. 			begin++;
  20. 		}
  21. 		Swap(&a[i], &a[min]);//交换
  22. 	}
  23. }

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

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

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

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

4. 稳定性：不稳定

3.堆排序

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

1.建堆：（对数组进行向下调整）

①升序：建大堆

②降序：建小堆

2. 利用堆删除思想来进行排序

建堆和堆删除中都用到了向下调整，用向下调整完成堆排序。

下图以排升序为例：

建立大堆，将最大的数与堆最后一个元素交换，size-1（此处不是删除数据，将最大的值排到最后，size-1后，该值不再参与向下调整），再从根节点向下排序选出次大值循环。

当前堆为建好的大堆：

 

 代码：

  1. void Swap(int* p1, int* p2)//交换数据
  2. {
  3. 	int tmp = *p1;
  4. 	*p1 = *p2;
  5. 	*p2 = tmp;
  6. }
  7.  
  8. void AdjustDown(int*a, int size, int parent)//向下调整
  9. {               //size为当前堆（需要调整的）元素个数  parent为向下调整的节点
  10. 	int child = parent * 2 + 1;
  11. 	while (child < size)
  12. 	{ //当前调整这建大堆，建小堆需要修改比较符号 ⬇（建小堆：<）
  13. 		if (child + 1 < size && a[child + 1] > a[child])
  14. 		{
  15. 			child++;
  16. 		}        // ⬇（建小堆：<）
  17. 		if (a[child] > a[parent])
  18. 		{
  19. 			Swap(&a[child], &a[parent]);
  20. 			parent = child;
  21. 			child = parent * 2 + 1;
  22. 		}
  23. 		else
  24. 		{
  25. 			break;
  26. 		}
  27. 	}
  28. }
  29.  
  30. void HeapSort(int* a, int n)//a为数组指针，n为数组的元素个数
  31. {    //先用向下调整建堆
  32. 	for (int i = (n - 1 - 1) / 2; i >= 0; i--)
  33. 	{
  34. 		AdjustDown(a, n, i);
  35. 	}
  36. 	int end = n - 1;
  37.  
  38. 	while (end>0)//将堆顶数据放到数组尾部，再次向下调整
  39. 	{
  40. 		Swap(&a[0], &a[end]);
  41. 		AdjustDown(a, end, 0);
  42. 		end--;
  43. 	}
  44. }

堆排序的特性总结：

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

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

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

4. 稳定性：不稳定

三、交换排序

1.基本思想：

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

2.冒泡排序

动图演示：（升序）

在这里插入图片描述

  1. void Swap(int* a, int* b)
  2. {
  3. 	int tmp = *a;
  4. 	*a = *b;
  5. 	*b = tmp;
  6. }
  7.  
  8. void BubbleSort(int* a, int n)
  9. {
  10. 	assert(a);
  11. 	for (int j = 0; j < n; j++)
  12. 	{
  13. 		int exchange = 0;
  14. 		for (int i = 1; i < n-j; i++)
  15. 		{
  16. 			if (a[i - 1] < a[i])
  17. 			{
  18. 				Swap(&a[i - 1], &a[i]);
  19. 				exchange = 1;
  20. 			}
  21. 		}
  22. 		if (exchange == 0)//如果没有发生交换则说明序列已经有序
  23. 		{
  24. 			break;
  25. 		}
  26. 	}
  27. }

冒泡排序的特性总结：

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

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

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

4. 稳定性：稳定

3.快速排序（递归实现）

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

1.hoare版本

步骤：（以排升序为例）

1.先从数列中取出一个数作为基准数key（一般取最左边或者最右边的值）。

2.分区过程，从最右边向左寻找比key小的值 与 从最左边向右寻找比key大的值交换。两者相遇的位置与key交换。将比这个数key大的数全放到它的右边，小于或等于它的数全放到它的左边。

3.再对左右区间重复第二步，直到各区间只有一个数（递归）。

 

 此时，key的左侧都比key小，右侧都比key大

再将左右区间重复第二步，直到各区间只有一个数（递归）。

代码：

  1. int PartSort1(int* a, int begin, int end)
  2. {
  3. 	int left = begin, right = end;
  4. 	int keyi = left;
  5.  
  6. 	while (left < right)
  7. 	{
  8. 		while (left < right && a[right] >= a[keyi])
  9. 		{
  10. 			--right;
  11. 		}
  12. 		while (left < right && a[left] <= a[keyi])
  13. 		{
  14. 			++left;
  15. 		}
  16. 		Swap(&a[left], &a[right]);
  17. 	}
  18. 	Swap(&a[keyi], &a[left]);
  19. 	return left;
  20. }
  21.  
  22. void QuickSort(int* a, int begin, int end)
  23. {
  24. 	if (begin >= end)//此时只有一个数据或者区间不存在
  25. 	{
  26. 		return;
  27. 	}            //hoare版本
  28. 	int keyi = PartSort1(a, begin, end);
  29. 	QuickSort(a, begin, keyi - 1);
  30. 	QuickSort(a, keyi + 1, end);
  31. }

 2.挖坑版本

步骤：（以排升序为例）

1．将基准数key挖出形成第一个坑a[L]。

2．R--由后向前找比它小的数，找到后挖出此数填前一个坑a[L]中。

3．L++由前向后找比它大的数，找到后也挖出此数填到前一个坑a[R]中。

4．再重复执行2，3二步，直到L==R，将基准数填入a[L]中。

 

再对key的左右区间递归。

 代码：

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

3.前后指针版本

步骤：（以排升序为例）

1.选出基准数key

2.prev指针指向序列开头，cur指针指向prev+1的数据。

3.若cur指向的内容小于key，则prev先向后移动一位，然后交换prev和cur指针指向的内容，然后cur指针++。

若cur指向的内容大于key，则cur指针直接++。如此进行下去，直到cur指针越界，此时将key和prev指针指向的内容交换即可。

 

再对key的左右区间递归。

 代码：

  1. int PartSort3(int* a, int begin, int end)
  2. {
  3. 	int prev = begin;
  4. 	int key = begin;
  5. 	int cur = begin+1;
  6.  
  7. 	int mid = GetMidIndex(a, begin, end);//三数取中（见下文）
  8. 	Swap(&a[key], &a[mid]);//三数取中
  9.  
  10. 	while (cur <= end)
  11. 	{
  12.  
  13. 		if (a[cur] < a[key] && ++prev != cur)
  14. 		{
  15. 			Swap(&a[cur], &a[prev]);
  16. 		}
  17. 		++cur;
  18. 	}
  19. 	Swap(&a[key], &a[prev]);
  20. 	return prev;
  21. }
  22.  
  23.  
  24. void QuickSort(int* a, int begin, int end)
  25. {
  26. 	if (begin >= end)
  27. 	{
  28. 		return;
  29. 	}
  30. 	if (end - begin < 10)//小区间优化（见下文）
  31. 	{
  32.         InsertSort(a + begin, end - begin + 1);
  33. 	}
  34. 	else
  35. 	{
  36. 		int keyi = PartSort3(a, begin, end);
  37. 		QuickSort(a, begin, keyi - 1);
  38. 		QuickSort(a, keyi + 1, end);
  39. 	}
  40. }

4.快速排序优化

1.三数取中

在理想情况下，快速排序的时间复杂度是O(N*logN)。

理想情况下，key的大小每次都是中间值，key左右两侧的区间长度相等。

但是当序列有序或者接近有序时，我们取最左边或最右边的数据就会取到最小或者最大值，此时的时间复杂度为O(N^2)，当数据过多时还可能会栈溢出。

 为了避免上述情况，我们取序列的最左、最右和中间的数据比较，却中间大小的数据作为key值。

代码：

  1. int GetMidIndex(int* a, int begin, int end)
  2. {
  3. 	int mid = (begin + end) / 2;
  4. 	if (a[begin] < a[end])
  5. 	{
  6. 		if (a[begin] > a[mid])
  7. 			return begin;
  8. 		else if (a[mid] < a[end])
  9. 			return mid;
  10. 		else
  11. 			return end;
  12. 	}
  13. 	else
  14. 	{
  15. 		if (a[mid] > a[begin])
  16. 			return begin;
  17. 		else if (a[mid] > a[end])
  18. 			return mid;
  19. 		else
  20. 			return end;
  21. 	}
  22. }

在上文的前后指针版本中有使用。

2.小区间优化

当待排序序列的数据个数较少时，我们遍不再使用快速排序对小区间进行递归，可以考虑用其他排序。小区间优化若是使用得当的话，会在一定程度上加快快速排序的效率，而且待排序列的长度越长，该效果越明显。

如：假设区间小于10，不再递归排序小区间，将减少80%以上的递归次数。

参考上文中的前后指针版本的代码：

  1. void QuickSort(int* a, int begin, int end)
  2. {
  3. 	if (begin >= end)
  4. 	{
  5. 		return;
  6. 	}
  7. 	if (end - begin < 10)//小区间优化
  8.     //当区间内数据小于10个，则使用插入排序
  9. 	{
  10.         InsertSort(a + begin, end - begin + 1);
  11. 	}
  12. 	else
  13. 	{
  14. 		int keyi = PartSort3(a, begin, end);
  15. 		QuickSort(a, begin, keyi - 1);
  16. 		QuickSort(a, keyi + 1, end);
  17. 	}
  18. }

5.快速排序（非递归实现）

快速排序的排序的非递归，需要借助栈来模拟递归。

步骤：

1.将需要排序的序列的左右区间按读取顺序入栈。

2.当栈不为空时，读取栈中左右区间的值，用上述3个版本中任意方法排序，获取key的值。比较key和左右区间的值，当key大于或等左或右区间的值时，说明该区间只有1个或不存在，此时该区间有序。若key小于左或右区间的值，将左区间--key 和key--右区间的值按读取顺序入栈。

3.重复步骤2，直至栈为空。

代码：

栈：（Stack.h）

  1. #include<stdio.h>
  2. #include<stdlib.h>
  3. #include<assert.h>
  4. #include<stdbool.h>
  5.  
  6. typedef int STDataType;
  7. typedef struct Stack
  8. {
  9. 	STDataType* a;
  10. 	int top;
  11. 	int capacity;
  12. }ST;
  13.  
  14. void StackInit(ST* ps);
  15. void StackDestory(ST* ps);
  16. void StackPush(ST* ps, STDataType x);
  17. void StackPop(ST* ps);
  18. STDataType StackTop(ST* ps);
  19. bool StackEmpty(ST* ps);
  20. int StackSize(ST* ps);

（Stack.c）

  1. #include"stack.h"
  2.  
  3. void StackInit(ST* ps)
  4. {
  5. 	assert(ps);
  6. 	ps->a = NULL;
  7. 	ps->top = 0;
  8. 	ps->capacity = 0;
  9. }
  10. void StackDestory(ST* ps)
  11. {
  12. 	assert(ps);
  13. 	free(ps->a);
  14. 	ps->a = NULL;
  15. 	ps->capacity = ps->top = 0;
  16. }
  17. void StackPush(ST* ps, STDataType x)
  18. {
  19. 	assert(ps);
  20. 	if (ps->top == ps->capacity)
  21. 	{
  22. 		int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
  23. 		STDataType* tmp = (STDataType*)realloc(ps->a, sizeof(STDataType) * newcapacity);
  24. 		if (tmp == NULL)
  25. 		{
  26. 			printf("realloc fail\n");
  27. 			exit(-1);
  28. 		}
  29. 		ps->a = tmp;
  30. 		ps->capacity = newcapacity;
  31. 	}
  32. 	ps->a[ps->top] = x;
  33. 	ps->top++;
  34. }
  35. void StackPop(ST* ps)
  36. {
  37. 	assert(ps);
  38. 	assert(!(StackEmpty(ps)));
  39. 	ps->top--;
  40. }
  41. STDataType StackTop(ST* ps)
  42. {
  43. 	assert(ps);
  44. 	assert(!(StackEmpty(ps)));
  45. 	return ps->a[ps->top - 1];
  46. }
  47. bool StackEmpty(ST* ps)
  48. {
  49. 	assert(ps);
  50. 	return ps->top == 0;
  51. }
  52. int StackSize(ST* ps)
  53. {
  54. 	assert(ps);
  55. 	return ps->top;
  56. }

快速排序非递归的三个版本与递归版本相同，直接引用即可。

  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. 		int right = StackTop(&st);
  14. 		StackPop(&st);
  15.                 //PartSort1、PartSort2 自行替换即可
  16. 		int keyi = PartSort3(a, left, right);
  17. 		
  18. 		if (keyi + 1 < right)
  19. 		{
  20. 			StackPush(&st, right);
  21. 			StackPush(&st, keyi+1);
  22. 		}
  23. 		if (keyi - 1 > left)
  24. 		{
  25. 			StackPush(&st, keyi-1);
  26. 			StackPush(&st, left);
  27. 		}
  28. 	}
  29. 	StackDestory(&st);
  30. }

快速排序的特性总结：

1. 快速排序整体的综合性能和使用场景都是比较好的

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

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

4. 稳定性：不稳定

四、归并排序

基本思想：

归并排序（MERGE-SORT）是建立在归并操作上的一种有效的排序算法,该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。

将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。

（以排升序为例）

 1.递归实现

将序列划分为左右两个子区间，进行递归，当左右两个子区间只有一个数据或不存在是，即为有序，对两子区间进行合并。

进行归并排序需要创建一个与原序列大小相同的空间，用于存放合并后的数据。合并完成后，拷贝回原序列。

  1. void _MergeSort(int* a, int begin, int end, int* tmp)
  2. {
  3. 	if (begin >= end)//当区间只有1个数据或不存在时，直接返回
  4. 		return;
  5. 	int mid = (begin + end) / 2;
  6. 	//递归
  7. 	_MergeSort(a, begin, mid, tmp);
  8. 	_MergeSort(a, mid + 1, end, tmp);
  9. 	//归并
  10. 	int begin1 = begin, end1 = mid;
  11. 	int begin2 = mid + 1, end2 = end;
  12. 	int i = begin1;
  13. 	//将两个子区间的数据从小到大依次存入创建的数组
  14. 	while (begin1 <= end1 && begin2 <= end2)
  15. 	{
  16. 		if (a[begin1] < a[begin2])
  17. 			tmp[i++] = a[begin1++];
  18. 		else
  19. 			tmp[i++] = a[begin2++];
  20. 	}
  21. 	//将剩余区间数据存入数组
  22. 	while (begin1 <= end1)
  23. 	{
  24. 		tmp[i++] = a[begin1++];
  25. 	}
  26. 	while (begin2 <= end2)
  27. 	{
  28. 		tmp[i++] = a[begin2++];
  29. 	}
  30. 	//拷贝回原序列
  31. 	memcpy(a+begin, tmp+begin, sizeof(int)*(end-begin+1));
  32. }

2.非递归实现

归并排序的非递归实现只需要对原序列分组进行归并即可。

当原序列数据个数正好为2的次方个时，上述情况才能正常运行。

当原序列数据个数不为2的次方个时，则需要对分组后的区间进行修正。

1.思路一：

将所有数据合并过一次后，统一拷贝回原序列。

 区间修正，以越界部分为例：

 其中当gap=1时，每个数据为一组，begin1一定不会越界。

 当end1>=n时，越界，end1置为n-1。begin2置为n，end2置为n-1，即该区间不存在。

当begin2>=n时，begin2置为n，end2置为n-1，即该区间不存在。

当只有end2>=n时，end2置为n-1。

代码：

  1. void MergeSortNonR(int* a, int n)
  2. {
  3. 	int* tmp = (int*)malloc(sizeof(int) * n);
  4. 	if (tmp == NULL)
  5. 	{
  6. 		printf("malloc");
  7. 		exit(-1);
  8. 	}
  9.  
  10. 	int gap = 1;
  11. 	while (gap<n)
  12. 	{
  13. 		int begin1, end1, begin2, end2;
  14. 		for (int i = 0; i < n; i += 2 * gap)//用gap划分区间
  15. 		{
  16. 			begin1 = i;
  17. 			end1 = i + gap - 1;
  18. 			begin2 = i + gap;
  19. 			end2 = i + 2 * gap - 1;
  20. 			int tmpi = begin1;
  21.  
  22. 			//区间修正
  23. 			if (end1 >= n)
  24. 			{
  25. 				end1 = n - 1;
  26. 				begin2 = n;
  27. 				end2 = n - 1;
  28. 			}
  29. 			else if(begin2>=n)
  30. 			{
  31. 				begin2 = n;
  32. 				end2 = n - 1;
  33. 			}
  34. 			else if (end2 >= n)
  35. 			{
  36. 				end2 = n - 1;
  37. 			}
  38.  
  39. 			//归并
  40. 			while (begin1 <= end1 && begin2 <= end2)
  41. 			{
  42. 				if (a[begin1] < a[begin2])				
  43. 					tmp[tmpi++] = a[begin1++];			
  44. 				else				
  45. 					tmp[tmpi++] = a[begin2++];				
  46. 			}
  47. 			while (begin1 <= end1)
  48. 			{
  49. 				tmp[tmpi++] = a[begin1++];
  50. 			}
  51. 			while (begin2 <= end2)
  52. 			{
  53. 				tmp[tmpi++] = a[begin2++];
  54. 			}
  55. 		}
  56. 		memcpy(a, tmp, sizeof(int) * n);//合并后拷贝回原序列
  57. 		gap*=2;
  58. 	}
  59. 	free(tmp);
  60. }


2.思路二：

只要有归并两组数据合并，就将其拷贝回原序列。

当end1>=n时，此时只有左区间存在，且已经合并到序列最后，直接跳出当前循环即可。

当begin2>=n时，同上。

当只有end2>=n时，此时左右区间都存在，需要合并，将end2置为n-1即可。

代码：

  1. void MergeSortNonR(int* a, int n)
  2. {
  3. 	int* tmp = (int*)malloc(sizeof(int) * n);
  4. 	if (tmp == NULL)
  5. 	{
  6. 		printf("malloc");
  7. 		exit(-1);
  8. 	}
  9.  
  10. 	int gap = 1;
  11. 	while (gap < n)
  12. 	{
  13. 		int begin1, end1, begin2, end2;
  14. 		for (int i = 0; i < n; i += 2 * gap)
  15. 		{
  16. 			begin1 = i;
  17. 			end1 = i + gap - 1;
  18. 			begin2 = i + gap;
  19. 			end2 = i + 2 * gap - 1;
  20. 			int tmpi = begin1;
  21. 			
  22. 			//区间修正
  23. 			if (end1 >= n || begin2 >= n)
  24. 			{
  25. 				break;
  26. 			}
  27. 			if (end2 >= n)
  28. 			{
  29. 				end2 = n - 1;
  30. 			}
  31. 			int m = end2 - begin1 + 1;//记录当前左右两个区间的数据个数
  32. 			//归并
  33. 			while (begin1 <= end1 && begin2 <= end2)
  34. 			{
  35. 				if (a[begin1] < a[begin2])
  36. 					tmp[tmpi++] = a[begin1++];
  37. 				else
  38. 					tmp[tmpi++] = a[begin2++];
  39. 			}
  40. 			while (begin1 <= end1)
  41. 			{
  42. 				tmp[tmpi++] = a[begin1++];
  43. 			}
  44. 			while (begin2 <= end2)
  45. 			{
  46. 				tmp[tmpi++] = a[begin2++];
  47. 			}
  48. 			memcpy(a+i, tmp+i, sizeof(int) * m);
  49. 		}
  50. 		gap *= 2;
  51. 	}
  52. 	free(tmp);
  53. }

归并排序的特性总结：

1. 归并的缺点在于需要O(N)的空间复杂度。

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

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

4. 稳定性：稳定

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/秋刀鱼在做梦/article/detail/736832?site
推荐阅读
相关标签

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

  

闽ICP备14008679号