数据结构排序比较

最新推荐文章于 2023-07-13 21:48:06 发布
最新推荐文章于 2023-07-13 21:48:06 发布
阅读量437 收藏
点赞数 2
分类专栏： C的数据结构 文章标签： 数据结构 排序算法 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wutongguo/article/details/129193412
版权
本文详细介绍了排序算法的基本概念，包括排序的稳定性、内部排序和外部排序。接着，对常见的排序算法进行了深入讲解，如直接插入排序、希尔排序、选择排序（直接选择和堆排序）、交换排序（冒泡排序和快速排序）以及归并排序，包括它们的实现原理、时间复杂度和空间复杂度。最后，探讨了快速排序的优化策略，如三数取中和小区间优化，并给出了非递归版本的快速排序和归并排序实现。
摘要由CSDN通过智能技术生成

排序的概念及其运用

(1)排序的概念

排序:所谓排序，就是使一串记录，按照其中的某个或某些关键字的大小，递增或递减的排列起来的操作。
稳定性:假定在待排序的记录序列中，存在多个具有相同的关键字的记录，若经过排序，这些记录的相对次 序保持不变，即在原序列中，r[i]=r[j]，且r[i]在r[j]之前，而在排序后的序列中，r[i]仍在r[j]之前，则称这种排
序算法是稳定的；否则称为不稳定的。
内部排序：数据元素全部放在内存中的排序。
外部排序：数据元素太多不能同时放在内存中，根据排序过程的要求不能在内外存之间移动数据的排序。

(2)常见的排序算法

分为插入排序和选择排序，交换排序，以及归并排序
大家好好对比一下区别

在这里插入图片描述

测试每个排序的性能

当我们将每个排序的代码写完，我们需要测试一下，每种排序的性能怎么样，就是我们可以用一下我们的时间差，来看每个排序的时间

// 测试排序的性能对比
void TestOP()
{
	srand(time(0));
	const int N = 100000;
	int* a1 = (int*)malloc(sizeof(int) * N);
	int* a2 = (int*)malloc(sizeof(int) * N);
	int* a3 = (int*)malloc(sizeof(int) * N);
	int* a4 = (int*)malloc(sizeof(int) * N);
	int* a5 = (int*)malloc(sizeof(int) * N);
	int* a6 = (int*)malloc(sizeof(int) * N);
	for (int i = 0; i < N; ++i)
	{
		a1[i] = rand();
		a2[i] = a1[i];
		a3[i] = a1[i];
		a4[i] = a1[i];
		a5[i] = a1[i];
		a6[i] = a1[i];
	}
	int begin1 = clock();
	InsertSort(a1, N);
	int end1 = clock();

	int begin2 = clock();
	ShellSort(a2, N);
	int end2 = clock();

	int begin3 = clock();
	SelectSort(a3, N);
	int end3 = clock();

	int begin4 = clock();
	HeapSort(a4, N);
	int end4 = clock();

	int begin5 = clock();
	QuickSort(a5, 0, N - 1);
	int end5 = clock();

	int begin6 = clock();
	MergeSort(a6, N);
	int end6 = clock();
	printf("InsertSort:%d\n", end1 - begin1);
	printf("ShellSort:%d\n", end2 - begin2);
	printf("SelectSort:%d\n", end3 - begin3);
	printf("HeapSort:%d\n", end4 - begin4);
	printf("QuickSort:%d\n", end5 - begin5);
	printf("MergeSort:%d\n", end6 - begin6);
	free(a1);
	free(a2);
	free(a3);
	free(a4);
	free(a5);
	free(a6);
}

插入排序

直接插入排序其基本思想是

直接插入排序是一种简单的插入排序法，把待排序的记录按其关键码值的大小逐个插入到一个已经排好序的有序序列中，直到所有的记录插入完为 止，得到一个新的有序序列 。

直接插入排序

我们先写单趟排序，我们最后一个需要排的数，直接插入。
等我们写完单趟排序，然后再写个循环，将其控制起来

我们的单趟排序

void InsertSort(int* a, int n)
{
	//我们先写单趟排序，假设n个数，
	//前n-1个数有序，只有最后一个乱序，直接插入

	//end表示有序数组的最后一个位置的下标,现在我们不知道
	int end;
	//将最后一个乱序的数保留下来，防止有序数组向后走将其覆盖
	int tmp = a[end + 1];
	//然后遍历一遍，知道将乱序的数放到他的位置
	//end是下标，是从0开始，所以遍历完数组需要将end>=0
	while (end >= 0)
	{
		//假设升序，如果tmp<a[end]就将其向后挪动，给tmp留空间
		if (tmp < a[end])
		{
			a[end + 1] = a[end];
			end--;
		}
		else
		{
			//如果在升序>=a[end],我们就不用动直接跳出来就行了
			break;
		}
	}
	//跳出来
	a[end] = tmp;
}

我们在外面套一层循环，然后控制直接插入排序。

void InsertSort(int* a, int n)
{
	//循环到n-1，就行了，自己画图看一下防止越界。
	for (int i = 0; i < n ; i++)
	{
		//我们先写单趟排序，假设n个数，
		//前n-1个数有序，只有最后一个乱序，直接插入
		//end表示有序数组的最后一个位置的下标,现在我们不知道
		int end = i;
		//将最后一个乱序的数保留下来，防止有序数组向后走将其覆盖
		int tmp = a[end + 1];
		//然后遍历一遍，知道将乱序的数放到他的位置
		//end是下标，是从0开始，所以遍历完数组需要将end>=0
		while (end >= 0)
		{
			//假设升序，如果tmp<a[end]就将其向后挪动，给tmp留空间
			if (tmp < a[end])
			{
				a[end + 1] = a[end];
				end--;
			}
			else
			{
				//如果在升序>=a[end],我们就不用动直接跳出来就行了
				break;
			}
		}
		//跳出来
		a[end + 1] = tmp;
	}
	
}

直接插入排序的时间复杂度

有的同学看到两层循环，就直接说是 O ( N 2 ) O(N^2) O(N2),但是并不是我们要自己分析一下

分为两种情况：
有最好和最坏的情况：
最好的情况是：顺序有序我们的时间复杂度O(N)
最坏的情况是：逆序，我们每个都要进行时间复杂度就是 O ( N 2 ) O(N^2) O(N2).

希尔排序

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

简而言之就是分为两步
1.预排序（分组排序）
2.插入排序

还是根直接插入排序一样，
将我们先写第一趟的希尔排序的代码。就是先把间距为gap的排好。
我们发现其实和直接插入排序的单趟排序一样，就是将1变为了gap而已，而且只是单趟中的一次交换

//希尔排序
void ShellSort(int* a, int n)
{
	int gap = 3;
	int end;
	//将最后一个乱序的数保留下来，防止有序数组向后走将其覆盖
	int tmp = a[end + gap];
	//然后遍历一遍，知道将乱序的数放到他的位置
	//end是下标，是从0开始，所以遍历完数组需要将end>=0
	while (end >= 0)
	{
		//假设升序，如果tmp<a[end]就将其向后挪动，给tmp留空间
		if (tmp < a[end])
		{
			a[end + gap] = a[end];
			end -= gap;
		}
		else
		{
			//如果在升序>=a[end],我们就不用动直接跳出来就行了
			break;
		}
	}
	//跳出来
	a[end + gap] = tmp;
}

那们将其变为单趟就再加一层循环，
自己分析一下代码，这是一整趟的希尔排序


//希尔排序
void ShellSort(int* a, int n)
{
	int gap = 3;
	for (int j = 0; j < gap; j++)
	{
		for (int i = j; i < n - gap; i += gap)
		{
			int end = i;
			int tmp = a[end + gap];
			while (end >= 0)
			{
				if (tmp < a[end])
				{
					a[end + gap] = a[end];
					end -= gap;
				}
				else
				{
					break;
				}
			}
			a[end + gap] = tmp;
		}
	}
}

下面将这个简化一下，效率没有任何提升，只是代码更简洁了。

//希尔排序
void ShellSort(int* a, int n)
{
	int gap = 3;
	//gap组并排，就是直接按照顺序排，只不过
	//不像刚才一组一组的。
	for (int i = 0; i < n - gap; ++i)
	{
		int end = i;
		int tmp = a[end + gap];
		while (end >= 0)
		{
			if (tmp < a[end])
			{
				a[end + gap] = a[end];
				end -= gap;
			}
			else
			{
				break;
			}
		}
		a[end + gap] = tmp;
	}
}

控制gap，实现多趟

//希尔排序
void ShellSort(int* a, int n)
{
	int gap = n;
	while (gap > 1)
	{
		//当gap=1的时候就是直接插入排序
		// 下面两种都是为了让最后一层gap=1.
		// 只不过第二中效率更高
		//gap = gap / 2;
		gap = gap / 3 + 1;


		//gap组并排，就是直接按照顺序排，只不过
		//不像刚才一组一组的。
		for (int i = 0; i < n - gap; ++i)
		{
			int end = i;
			int tmp = a[end + gap];
			while (end >= 0)
			{
				if (tmp < a[end])
				{
					a[end + gap] = a[end];
					end -= gap;
				}
				else
				{
					break;
				}
			}
			a[end + gap] = tmp;
		}
	}
	
}

希尔排序的理解

我们要理解我们的gap的作用
gap>1,就是我们的预排序
gap=1,就是我们的直接插入排序。

我感觉大家跟我第一次学的时候，一样感觉这个有点挫，最后都是是进行直接插入排序吗？为什们不直接用呢？

其实并不是，如果一组数是逆序排列，要排升序，最大的数在最前面，最小的数在最后面，我们要和每个数进行比较，然后才能到他的位置。

而我们希尔排序，利用gap，极大的减轻了他的负担，将大或小的数以gap步向它的位置靠近，让我们最后一次的直接插入排序十分轻松。

对于预排序来说 gap有什们要求没有？
1. gap越大，大的数可以更快的到后面，小的可以更快的到前面，却不接近有序。
2. gap越小，数据跳动的越慢，也就越接近有序。

希尔排序的时间复杂度

他其实比较难算，类似于一种期望公式，可以想象一下，就是乱序，越来越变得有序,这种必须那种具有数学很高的素养的人才有可能算出来。我们就估算就可以

我们大概估算约等于 O ( N 1.3 ) O(N^{1.3}) O(N1.3)

选择排序

我们的选择排序有选择排序和堆排序，堆排序我们介绍过了，就不多介绍了，我们主要讲选择排序。

直接选择排序

就是遍历一遍数组，选出最小的，放到第一个，然后再除了第一个选最小的放到开始。

那我们升级一下，再选最小的时候，同时选出最大的，放到开始和结尾，这样就会更快。直接看代码吧，太简单你了。

//直接选择排序
void SelectSort(int* a, int n)
{
	int begin = 0;
	int end = n - 1;
	int min = begin;
	int max = begin;
	while (begin < end)
	{
		for (int i = begin + 1; i <= end; i++)
		{
			if (a[i] < a[min])
			{
				min = i;
			}
			if (a[i] > a[max])
			{
				max = i;
			}
		}
		Swap(&a[begin], &a[min]);
		if (max == begin)
		{
			max = min;
		}
		Swap(&a[end], &a[max]);
		begin++;
		end--;
	}
	
}

直接选择排序的时间复杂度

O ( N 2 ) O(N^2) O(N2),很简单我们自己分析一下。

堆排序

我们在我们将堆的时候已经写过一会了，我们就不重复了，大家自己看《堆的概念和结构以及堆排序》就可以了。
我给一下这个堆排序的c代码

//交换元素
void Swap(int* p1, int * p2)
{
	assert(p1 && p2);
	int tmp = *p1;
	*p1 = *p2;
	*p2 = tmp;
}
//向下调整
void AdjustDown(int* a, int n, int parent)
{
	int child = parent * 2 + 1;

	while (child < n)
	{
		if (child + 1 < n && a[child + 1] > a[child])
		{
			child += 1;
		}

		if (a[child] > a[parent])
		{
			Swap(&a[child], &a[parent]);
			parent = child;
			child = parent * 2 + 1;
		}
		else
		{
			break;
		}
	}


}
void HeapSort(int*a, int n)
{
	assert(a);
	for (int i = (n - 1 - 1) / 2; i >= 0; i--)
	{
		AdjustDown(a, n, i);
	}
	for (int i = 0; i < n; i++)
	{
		Swap(&a[0], &a[n - 1 - i]);
		AdjustDown(a, n - 1 - i, 0);
	}
}

交换排序

我们的交换排序，有两种一个是冒泡排序和快速排序

冒泡排序

我们的冒泡排序比直接选择排序还简单，就是注意控制一下循环就好了

//冒牌排序
void BubbleSort(int* a, int n)
{
	for (int i = 0; i < n -1; i++)
	{
		for (int j = 1; j <= n - 1 - i; j++)
		{
			if (a[j] < a[j-1])
			{
				Swap(&a[j], &a[j - 1]);
			}
		}
	}
}

快速排序（递归）

快排的单趟排序(升序)
左边的值比key要小，右边的值比key要大。key一般是做左边的值。找两个变量一个控制左，一个控制右。一个叫L，一个叫R。
单趟排序的意义
1.分割出左右区间，左区间比key小，右区间比key大
2.key已经落到他的正确的位置（排序的最终位置）。
剩下的问题
左区间有序，右区间有序，那么整体就ok了。
就是将大问题转换为小问题，用递归解决。
单趟的规定
左边做key，右边先走；能够保证相遇位置比key小。
右边做key，左边先走，能够保证相遇位置比key大。
为什们要这么规定？
会遇到两种情况
1.相遇，一种是R停住，L遇到R。相遇的位置就是R停住的位置
2.相遇，一种是L停住，R遇到L。相遇的位置就是L停住的位置。
因为只有R先走，因为R停住位置小于key，这样才能保证这两个位置都比key小。交换才可以key左边小右边大

快排的单趟排序。

（1） hoare版本
//快速排序
void QuickSort(int* a, int n)
{
	int left = 0;
	int right = n - 1;
	//防止出现下面的问题，将key变成下标
	//int key = a[left];
	int key = left;
	while (left < right)
	{
		//右边先走，找小
		//加等于的意思就是我们防止等于key造成死循环
		//left<right防止我们key右边的值都大于key造成越界
		while (left<right&&a[right] >= a[key])
		{
			right--;
		}
		//左边再走，找大
		while (left < right && a[left] <= a[key])
		{
			left++;
		}
		Swap(&a[left], &a[right]);
	}
	//不能跟key换，key是一个局部变量，所以将key成下标，这样就能修改数组。
	//Swap(&a[left], &key);
	Swap(&a[left], &a[key]);


}

快排递归代码

//快速排序
void QuickSort(int* a, int begin,int end)
{
	//递归结束条件
	if (begin >= end)
	{
		return;
	}

	int left = begin;
	int right = end ;
	//防止出现下面的问题，将key变成下标
	//int key = a[left];
	int key = left;
	while (left < right)
	{
		//右边先走，找小
		//加等于的意思就是我们防止等于key造成死循环
		//left<right防止我们key右边的值都大于key造成越界
		while (left<right&&a[right] >= a[key])
		{
			right--;
		}
		//左边再走，找大
		while (left < right && a[left] <= a[key])
		{
			left++;
		}
		Swap(&a[left], &a[right]);
	}
	//不能跟key换，key是一个局部变量，所以将key成下标，这样就能修改数组。
	//Swap(&a[left], &key);
	Swap(&a[left], &a[key]);
	key = left;

	//然后就分为了三个区间
	//[begin,key-1] key [key+1,end]
	QuickSort(a, begin, key - 1);
	QuickSort(a, key + 1, end);

}
（2）挖坑法

我们挖坑法的思路就是，挖坑填坑的思路
我们先将key的位置挖坑，在挖坑之前将我们的key的下标保存下来，然后我们还是先从右边找比他小的位置，（至于为什们找比它小的位置原理跟上面一样）然后将这个小的位置填到我们前面的坑里，
然后再从左边找比他大的位置，找到后填到上一个坑位中，这样依次类推，我们最后左大于等于右后，就停下来，把我们的key放到坑中，就是这样。

// 挖坑版本的单趟排序
int PartSort2(int* a, int begin, int end)
{
	int mid = GetMidIndex(a, begin, end);
	Swap(&a[begin], &a[mid]);

	int left = begin;
	int right = end;
	//防止出现下面的问题，将key变成下标
	//int key = a[left];
	int key = a[left];
	int hole = left;
	while (left < right)
	{
		//右边找小，填到坑中
		while (left < right && a[right] >= key)
		{
			right--;
		}
		a[hole] = a[right];
		hole = right;
		//左边找大，填到右边的坑中
		while (left < right && a[left] <= key)
		{
			left++;
		}
		a[hole] = a[left];
		hole = left;
	}
	
	a[hole] = key;
	return hole;
}
（3）双指针

思路:
1.cur找比key小，找到后停下来
2.++pre，交换prev位置和cur位置的值
3.等cur超出数组，我们将pre和key最后交换。在这里插入图片描述

// 快速排序前后指针法
int PartSort3(int* a, int left, int right)
{
	int mid = GetMidIndex(a, left, right);
	Swap(&a[left], &a[mid]);

	int key = left;
	int pre = left;
	int cur = left + 1;
	while (cur <= right)
	{
		if (a[cur] < a[key] && ++pre != cur)
		{
			Swap(&a[pre], &a[cur]);
		}
		cur++;

	}
	Swap(&a[pre], &a[key]);
	key = pre;
	return key;
	
}

快排的时间复杂度

先算快排的单趟，就是遍历一边数组，就是经典的O(N)。

递归的时间复杂度好像看着代码来分析
我们可以想最好情况和最坏情况分析

最好情况就是：在每次递归的时候都是在key都是在中间。
假设N个值，
这个满二叉树的高度就是 l o g 2 ( N ) log_2(N) log2​(N)，每一层看作N
他的时间复杂度就是 O ( N ∗ l o g ( N ) ) O(N*log(N)) O(N∗log(N))
在这里插入图片描述

最坏情况：每次选key都是最大或者最小
实际情况：有序
时间复杂度就是 O ( N 2 ) O(N^2) O(N2),就是想当于冒泡排序。
在这里插入图片描述

快排的空间复杂度

就是算我们创建了多少层栈帧，我们看上面的图知道，创建了 O ( l o g N ) O(logN) O(logN)个栈帧.我们知道栈帧是可以重复利用的。
所以我们的空间复杂度就是 O ( l o g N ) O(logN) O(logN)

快排的缺点

当我们的数据是有序，或者接近有序的，我们的快排就会一直占用函数栈帧，导致我们的栈溢出，造成极大的风险。

三数取中法

如果是有序的，我们的key就不需要动，就一直要递归，最终造成栈溢出，并且他这时的效率就会很低。
我们选中间的的数，然后跟key交换，就可以很好的解决这个问题

//三数取中
//beigin  mid end
int GetMidIndex(int* a, int begin, int end)
{
	int mid = (begin + end) / 2;
	if (a[begin] < a[mid])
	{
		if (a[mid] < a[end])
		{
			return mid;
		}
		else if (a[begin]>a[end])
		{
			return begin;
		}
		else
		{
			return end;
		}
	}
	else//begin>mid
	{
		if (a[mid] > a[end])
		{
			return mid;
		}
		else if (a[begin] < a[end])
		{
			return begin;
		}
		else
		{
			return end;
		}
	}
}
//快速排序
void QuickSort(int* a, int begin,int end)
{
	//递归结束条件
	if (begin >= end)
	{
		return;
	}
	int mid = GetMidIndex(a, begin, end);
	Swap(&a[begin], &a[mid]);

	int left = begin;
	int right = end ;
	//防止出现下面的问题，将key变成下标
	//int key = a[left];
	int key = left;
	while (left < right)
	{
		//右边先走，找小
		//加等于的意思就是我们防止等于key造成死循环
		//left<right防止我们key右边的值都大于key造成越界
		while (left<right&&a[right] >= a[key])
		{
			right--;
		}
		//左边再走，找大
		while (left < right && a[left] <= a[key])
		{
			left++;
		}
		Swap(&a[left], &a[right]);
	}
	//不能跟key换，key是一个局部变量，所以将key成下标，这样就能修改数组。
	//Swap(&a[left], &key);
	Swap(&a[left], &a[key]);
	key = left;

	//然后就分为了三个区间
	//[begin,key-1] key [key+1,end]
	QuickSort(a, begin, key - 1);
	QuickSort(a, key + 1, end);

}
加入三数取中后的时间复杂度

使用三数取中以后，快排瞬间从最坏变成最好
快排几乎不会出现最坏的情况
快排的时间复杂度就是 O ( N ∗ l o g N ) O(N*logN) O(N∗logN)

小区间优化(减少递归次数)

我们当递归到最后，分割分割，假设剩10个数，光递归高度最少也得4次，而且高度越低，结点越多，假设高度是h，那最后一层的递归调用 2 h − 1 2^h-1 2h−1
就是我们杀鸡用牛刀，即浪费了空间，又浪费了时间。

在这里插入图片描述

所以当数据量小的时候，我们既不用的了递归了，我们用直接插入排序。

我们的减少区间的代码就是在快速排序的递归条件中加一个条件，如果我们递归的数小于15个数，我们就用直接插入排序。

	//小区间优化,减少递归调用
	//因为是闭区间，所以要加1
	if ((end - begin + 1) < 15)
	{
		InsertSort(a + begin, end - begin + 1);
	}
	else
	{
		int key = PartSort3(a, begin, end);
		
		QuickSort(a, begin, key - 1);
		QuickSort(a, key + 1, end);
	}

快速排序（非递归）

我们的非递归就是，还是用他的单趟排序，和递归的思路还是一样，而我们的递归就是传我们的区间。

我们非递归的重点就是将区间保存下来，我们的思路就是用栈将区间保存下来，至于怎么保存，大家看看代码。重要的就是利用了栈的功能。

/快排（非递归）
void QuickSortNonR(int* a, int begin, int end)
{
	ST st;
	StackInit(&st);
	StackPush(&st, begin);
	StackPush(&st, end);
	while (!StackEmpty(&st))
	{
		int right = StackTop(&st);
		StackPop(&st);
		int left = StackTop(&st);
		StackPop(&st);
		//进行单趟排序
		int key = PartSort1(a, left, right);
		//[left,key-1][key][key+1,right]
		if (key + 1 < right)
		{
			StackPush(&st, key + 1);
			StackPush(&st, right);
		}
		if (left < key - 1)
		{
			StackPush(&st, left);
			StackPush(&st, key - 1);
		}
	}


	StackDestroy(&st);
}

归并排序

归并排序（递归）

归并的单趟思想

归并的思想
归并排序是建立在 归并操作上的一种有效的排序算法,该算法是采用分治法的一个非常典型的应用。
将已有序的子序列合并，得到完全有序的序列；
即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。
在这里插入图片描述

所以我们写单趟排序，就是将两个有序的数组，合并成一个有序的数组。
这就是我们的大思路。

注意：我们再归并两个数组的时候，我们不能修改原数组，如果将原本的内容覆盖，我们就不能进行比较了，所以我们创建一个临时数组，将比较的内容放到临时数组上然后在拷贝到原数组。

归并递归代码

//归并排序的子函数
void _MergeSort(int* a, int left, int right, int* tmp)
{
	//结束条件
	if (left >= right)
	{
		return;
	}

	//分割左右两部分
	int mid = (left + right) / 2;
	// [0~mid] [mid+1~right]
	
	//递归将其变有序
	_MergeSort(a, left, mid, tmp);
	_MergeSort(a, mid + 1, right, tmp);

	//这是经过递归就会产生两个有序的数组
	//而归并的单趟就是将两个有序的数组合并成一个有序的数组

	//我们就不要用上面的变量了，重新定义一个
	int begin1 = left, end1 = mid;
	int begin2 = mid + 1, end2 = right;
	int n = left;
	while (begin1 <= end1 && begin2 <= end2)
	{
		if (a[begin1] < a[begin2])
		{
			tmp[n++] = a[begin1++];
		}
		else
		{
			tmp[n++] = a[begin2++];
		}
	}
	while (begin1 <= end1)
	{
		tmp[n++] = a[begin1++];
	}
	while(begin2 <= end2)
	{
		tmp[n++] = a[begin2++];
	}
	memcpy(a + left, tmp + left, sizeof(int) * (right - left + 1));
}

// 归并排序递归实现
void MergeSort(int* a, int n)
{
	//创建一个数组，就是防止我们在递归的过程中产生覆盖
	int* tmp = (int*)malloc(sizeof(int) * n);
	if (tmp == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}
	_MergeSort(a, 0, n - 1, tmp);
}

归并排序的时间复杂度和空间复杂度

时间复杂度: O ( N ∗ l o g N ) O(N*logN) O(N∗logN)
空间复杂度:O(N)

空间复杂度：也要算栈帧，但是 l o g N logN logN可以忽略不记

归并排序（非递归）

我们快排，是用栈，是因为他是前序
而我们的递归是后序，就不能用这个。

我们就控制每个区间就可以归并了，因为归并是二分。
我们的区间可以很好的控制，不想快排不是二分控制不了。

但是思路简单，但是代码是什们复杂的
rangeN表示每组归并的数据个数

在这里插入图片描述
在这里插入图片描述

归并非递归代码

// 归并排序非递归实现
void MergeSortNonR(int* a, int n)
{
	int* tmp = (int*)malloc(sizeof(int) * n);
	if (tmp == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}

	//归并每组的数据个数，从1开始，因为认为1个数是有序的，就可以直接归并
	int rangeN = 1;
	while (rangeN < n)
	{
		for (int i = 0; i < n; i += 2 * rangeN)
		{
			//[begin1,end1] [begin2,end2]
			//将上面归并的内容拿下来

			int begin1 = i, end1 = i + rangeN - 1;
			int begin2 = i + rangeN, end2 = i + 2 * rangeN - 1;
			int n = i;
			while (begin1 <= end1 && begin2 <= end2)
			{
				if (a[begin1] < a[begin2])
				{
					tmp[n++] = a[begin1++];
				}
				else
				{
					tmp[n++] = a[begin2++];
				}
			}
			while (begin1 <= end1)
			{
				tmp[n++] = a[begin1++];
			}
			while (begin2 <= end2)
			{
				tmp[n++] = a[begin2++];
			}
			//归并一部分，拷贝一部分
			memcpy(a + i, tmp + i, sizeof(int) * (end2 - i + 1));
		}
	}

	free(tmp);
	tmp = NULL;
}

非递归代码问题

我们合并两个有序数组的时候，我们需要控制区间，但是我们的两个区间并没有进行控制，就会发生溢出，导致程序的崩溃。
在这里插入图片描述

经过分析，共有三种越界
分别是：
1.end1越界，begin2越界，end2越界
2.begin2越界，end2越界
3.end2越界

非递归正确代码

// 归并排序非递归实现
void MergeSortNonR(int* a, int n)
{
	int* tmp = (int*)malloc(sizeof(int) * n);
	if (tmp == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}

	//归并每组的数据个数，从1开始，因为认为1个数是有序的，就可以直接归并
	int rangeN = 1;

	while (rangeN < n)
	{

		for (int i = 0; i < n; i += 2 * rangeN)
		{
			//[begin1,end1] [begin2,end2]
			//将上面归并的内容拿下来
			int begin1 = i, end1 = i + rangeN - 1;
			int begin2 = i + rangeN, end2 = i + 2 * rangeN - 1;
			printf("[%d,%d][%d,%d]\n", begin1, end1, begin2, end2);
			int j = i;
			
			// end1 begin2 end2 越界
			if (end1 >= n)
			{
				break;
			}
			else if (begin2 >= n)
			{
				break;
			}
			else if (end2 >= n)
			{
				end2 = n - 1;
			}
			
			while (begin1 <= end1 && begin2 <= end2)
			{
				if (a[begin1] <= a[begin2])
				{
					tmp[j++] = a[begin1++];
				}
				else
				{
					tmp[j++] = a[begin2++];
				}
			}
			
			while (begin1 <= end1)
			{
				tmp[j++] = a[begin1++];
			}
			
			while (begin2 <= end2)
			{
				tmp[j++] = a[begin2++];
						}
			//归并一部分，拷贝一部分
			memcpy(a + i, tmp + i, sizeof(int) * (end2 - i + 1));
		}
		rangeN *= 2;
	}

	free(tmp);
	tmp = NULL;
}

排序比较

选择排序的稳定性：不稳定
举例：在这里插入图片描述

在这里插入图片描述

桐桐超努力
关注
专栏目录
数据结构中几种常见的排序算法之比较
01-15
数据结构中几种常见的排序算法之比较，比较常见的冒泡排序、快速排序等
数据结构思维导图-排序.pdf
08-23
以上是数据结构中关于排序的一些基本知识，包括排序的稳定性、比较次数、内部排序和外部排序的定义，以及直接插入排序、折半插入排序、希尔排序和冒泡排序的原理和特点。这些排序算法各有优缺点，选择哪种排序算法取...
数据结构之各种排序的比较
fengxiaoke_fxk的专栏
09-02 4942
（一）直接插入排序 算法简洁，但是只有当待排元素n比较少的时候效率才高 所需空间：一个当前元素的哨兵array[0]即可 所需时间：主要与所需关键字的比较次数及移动的次数有关 最坏的情况——逆序：总的比较次数为n(n-1)/2，记录的移动次数也为n(n-1)/2 最好的情况——正序：比较次数为n-1，记录移动次数为0 由此可以推断出插入排序算法的平均时间为O(n^2)，最坏的情况为
数据结构复习之【排序】
mmdev
02-28 364
排序：对一序列对象根据某个关键字进行排序； 稳定：如果a原本在b前面，而a=b，排序之后a仍然在b的前面； 不稳定：如果a原本在b的前面，而a=b，排序之后a可能会出现在b的后面； 内排序：所有排序操作都在内存中完成； 外排序：由于数据太大，因此把数据放在磁盘中，而排序通过磁盘和内存的数据传输才能进行； 排序耗时的操作：比较、移动； 排序分类： (1)交换类：冒泡排序、快...
数据结构各类排序算法对比
chumengwa0046的博客
04-09 484
各类排序算法对比 时间复杂度来说： (1)平方阶(O(n2))排序 　　各类简单排序:直接插入、直接选择和冒泡排序； (2)线性对数阶(O(nlog2n))排序 　　快速排序、堆排序和归并排序； (3)O(n1+§))排序,§是介于0和1之间的常数。 希尔排序 (4)线性阶(O(n))排序 　　基数排序，此外还有桶、箱排序。 说明： 当原表有序或基本有序时，...
数据结构排序算法比较
风华绝代
09-23 344
快速排序java package codeB; public class 快速排序 { //METHOD SIGNATURE BEGINS, THIS METHOD IS REQUIRED public static void quickSort(int[] arr,int low,int high) { // INSERT YOUR CODE HERE if(lo...
数据结构排序问题实现总结.doc
04-03
本资料重点讨论了数据结构中的排序问题及其实现。 排序是数据处理的基础操作之一，它将无序的元素序列转换为有序序列。在数据结构中，有多种排序算法，每种算法都有其独特的性能特征。例如，冒泡排序是一种简单的...
C++数据结构排序算法
09-13
C++数据结构排序算法总结将为您提供详细的排序算法知识，包括比较排序和非比较排序两大类。 比较排序 比较排序是指通过比较元素的大小来确定其在序列中的位置的排序算法。比较排序算法的时间复杂度通常高于非比较...
c语言 数据结构 快速排序算法
04-28
c语言版本的数据结构的快速排序算法，适用于新手学习
哈工大数据结构实验5_冒泡排序与快速排序
03-26
实验项目：排序方法的实验比较 排序方法是数据处理的最基本和最重要的操作。其目的是将一组“无序”的 记录序列调整为“有序”的记录序列。 实验题目：排序方法的实现与实验比较 实验内容： 实现一组经典的排序...
数据结构----各种排序算法的比较
xn4545945
09-05 1956
一．实验目的    实现常用的排序算法，加深对这些算法的理解，以后可以将这些算法应用到实际问题的解决上。  二．实验题目 排序是在实际问题中经常用到的算法，快速、选择和插入三种排序算法是排序算法中最简单的也是最常用到的，实现这三种算法，在不同的数值序列上运行，然后比较三种方法的空间复杂度和时间复杂度，分析比较结果，得出选择这三种排序算法的一般原则。 三．实现提示 1．待排
【数据结构】排序7——各种排序方法的比较
FishC的博客
11-07 1215
【数据结构】排序7——各种排序方法的比较
【数据结构】8种排序的比较
qq_42270373的博客
11-09 804
  直接插入排序 ①所给元素越接近有序，直接插入排序的时间效率越高 ②时间复杂度: O(N^2) ③空间复杂度: O(1) ④稳定性: 稳定 希尔排序 ①希尔排序是对直接插入排序的优化  ②当gap &gt; 1时，都是预排序，目的是让数组更接近于有序； 当gap == 1时，数组已经接近有序的了，这样就会很快。这样整体  而言，可以达到优化的效果    ③时间复杂度：希尔排序...
数据结构：各种排序算法的比较
houyiming
01-16 610
数据结构：各种排序算法的比较 #include<bits/stdc++.h> using namespace std; int l[10000000]; long long length,com=0,move=0,t;//数据存储，长度，比较次数，移动次数。 void insertsort(int *l) //直接插入排序。 { com=move=0; for(int i=2;i<=length;i++) { com++; if(l[i]<l[i-1]) {
数据结构中各种排序算法比较
smile的博客
11-08 5860
1  快速排序（ QuickSort ）     快速排序是一个就地排序，分而治之，大规模递归的算法。从本质上来说，它是归并排序的就地版本。快 速排序可以由下面四步组成。     （ 1 ）   如果不多于 1 个数据，直接返回。   （ 2 ）   一般选择序列最左边的值作为支点数据。   （ 3 ）   将序列分成 2 部分，一部分都
数据结构--常用比较排序
xd6905的博客
11-20 1814
目录 一、冒泡排序 二、选择排序 三、插入排序 四、希尔排序 五、堆排序 六、快速排序 6.1 key位置选择 6.2 一趟排序的方法 hoare版本 挖坑法 前后指针法 6.3 完整排序 七、归并排序 一、冒泡排序 每个新手第一个学的排序。 一趟：将当前位置的值与下一个比较，如果当前值大于下一个位置的值则交换（升序），一趟可以做到把最大值放在最后位置。 n个数n-1躺：第一趟比较n-1次，第二趟就只要比较n-2次，最后第...
【数据结构】常见排序算法的比较
Jacky_Feng的博客
08-26 785
常见排序算法的比较前言一、各种排序算法比较 前言 对于各种排序算法的性能我们可以从时间复杂度、空间复杂度、特殊情况和稳定性四个方面来比较。其中特殊情况是指当序列为有序时，对排序算法复杂度的影响。 一、各种排序算法比较 排序算法 时间复杂度 空间复杂度 序列有序 稳定性 直接插入排序 O(n^2) O(1) O(n) 稳定 希尔排序 O(n^1.3) O(1) / 不稳定 冒泡排序 O(n^2) O(1) O(n) 稳定 快速排序 O(nlog2 n) O(log2 n) O(
数据结构几种常见的排序算法比较
最新发布
weixin_70947653的博客
07-13 152
数据结构中,常见的排序算法有起泡法,直接插入法,简单选择法,快速排序法,希尔排序,堆排序法,其中每种算法对数据的比较次数和平均移动次数不同,在此,运用C++仿真将每种算法的优略性进行对比。2.关键字移动次数上，冒泡法需要不断的交换来冒泡，因此其交换次数远大于其他方法，而移动次数最少的是简单选择，该方法是在找到插入位置后才进行交换，因此交换次数最少。如此重复下去，直到整个序列“基本有序”时，再对全体记录进行一次直接插入排序。减小增量，将序列分割为更大、更有序的子序列，再分别进行直接插入排序。
数据结构七大排序算法图解
二哈喇子！
04-27 2689
详细整理——七大排序（代码+动图演示） ...
数据结构排序习题与解答
"数据结构--排序测试习题及答案，包含考试绝大部分题型" 排序是数据结构中的一个重要概念，涉及到如何有效地对一组数据进行排列。本资源提供的习题集涵盖了多种排序算法及其特性，旨在帮助学习者巩固和理解排序算法...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

桐桐超努力

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值