数据结构之排序

于 2023-04-16 20:02:55 发布
阅读量48 收藏
点赞数
分类专栏： 排序 文章标签： 数据结构 排序算法 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_72387202/article/details/130183805
版权

文章目录

1.直接插入排序

  1. 基本思想：

把待排序的记录按其关键码值的大小逐个插入到一个已经排好序的有序序列中，直到所有的记录插入完为止，得到一个新的有序序列 。
以升序为例，在代码中，插入过程中，待插入的数与前面已经排好序的进行比较，比它大的往后挪，比它小就直接插入。

在这里插入图片描述

  1. 代码实现
//最坏：O(N^2)逆序
//最好：O(N)有序
//插入排序
void InsertSort(int* a, int n)
{
	for (int i = 1; i < n; i++)
	{
		int end = i - 1;//下标
		//首先保存要排序的数，一会就会被覆盖了
		int tmp = a[i];//插入的数据
		while (end >= 0)//下标控制循环
		{
			//小就往后挪动数据
			if (tmp < a[end])
			{
				a[end + 1] = a[end];
				end--;
			}
			else
			{
				break;
			}
		}
		a[end + 1] = tmp;//1、大的就直接往后放；2、小的往后挪break了或者不满足循环条件（最小数据，其它都往后挪）
	}
}
int main()
{
	int a[] = { 10,8,5,2,4,6,7,3,2,5 };
	int n = sizeof(a) / sizeof(a[0]);
	InsertSort(a, n);
	for (int i = 0; i < n; i++)
	{
		printf("%d ", a[i]);
	}
	return 0;
}

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

  1. 元素集合越接近有序，直接插入排序算法的时间效率越高
  2. 时间复杂度：最坏：O(N2)；最好：O(N)
  3. 空间复杂度：O(1)，它是一种稳定的排序算法
  4. 稳定性：稳定

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

  1. 排序思想：

把要排序的数分为gap组（gap是多少，就有多少组），gap为每一组数中的间隔，先对每一组的数进行排序，逐渐减小gap，当gap等于1的时候就是直接插入排序，随后完成排序。

在这里插入图片描述
2. 代码实现

//希尔排序
//最好：O(N^1.3)
//最坏：O(N^2)
void ShellSort(int* a, int n)
{
	//一组排完，再排另一组
	/*int gap = 3;//一次跳gap步
	for (int j = 0; j < gap; j++)
	{
		for (int i = gap+j; i < n; i += gap)
		{
			int end = i - gap;
			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;
			//1、大的就直接往后放；2、小的往后挪break了或者不满足循环条件（最小数据，其它都往后挪）
		}
	}*/
	/*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[ i + gap];
			while (end >= 0)
			{
				if (tmp < a[end])
				{
					a[end + gap] = a[end];
					end -= gap;
				}
				else
				{
					break;
				}
			}
			a[end + gap] = tmp;
		}
	}*/

	//多组并排
	/*int gap = 3;
	for (int i = 0; i < n - gap; i++)
	{
		int end = i;
		int tmp = a[i + gap];
		while (end >= 0)
		{
			if (tmp < a[end])
			{
				a[end + gap] = a[end];
				end -= gap;
			}
			else
			{
				break;
			}
		}
		a[end + gap] = tmp;
	}*/
	//到此演示单趟gap排序，下面的最终代码
	int gap = n;
	//不能写成大于0,因为gap的值始终>=1
	while (gap > 1)
	{
		//gap /= 2;//没次/=2用来控制循环，最后gap==1为直接插入排序来完成排序
		//只有gap最后为1，才能保证最后有序
		//所以这里要加1
		gap = gap / 3 + 1;
		//这里只是把插入排序的1换成gap即可
		//但是这里不是排序完一个分组，再去
		//排序另一个分组，而是整体只过一遍
		//这样每次对于每组数据只排一部分
		//整个循环结束之后，所有组的数据排序完成
		for (int j = 0; j < gap; j++)//gap是多少，就有多少组数据，完成gap组排序
		{
			for (int i = gap + j; i < n; i += gap)//完成一组排序
			{
				int end = i - gap;
				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;
				//1、大的就直接往后放；2、小的往后挪break了或者不满足循环条件（最小数据，其它都往后挪）
			}
		}
		//PrintArrar(a, n);//测试每一次希尔排序后数组的变化
	}
}
int main()
{
	int a[] = { 10,8,5,2,4,6,7,3,2,5 };
	int n = sizeof(a) / sizeof(a[0]);
	ShellSort(a, n);
	for (int i = 0; i < n; i++)
	{
		printf("%d ", a[i]);
	}
	return 0;
}

特性总结：

  1. 希尔排序是对直接插入排序的优化。
  2. 当gap > 1时都是预排序，目的是让数组更接近于有序。当gap == 1时，数组已经接近有序的了，这样就会很快。这样整体而言，可以达到优化的效果。我们实现后可以进行性能测试的对比。
  3. 希尔排序的时间复杂度不好计算，因为gap的取值方法很多，导致很难去计算，因此在好些树中给出的希尔排序的时间复杂度都不固定，最好：O(N1.3)，最坏：O(N2)。
  4. 稳定性：不稳定。

3.选择排序

  1. 排序思想：

第一种：每一次从待排序的数据元素中选出最小（或最大）的一个元素，与待排序起始位置，直到全部待排序的数据元素排完 。
第二种：每一次从待排序的数据元素中选出最小的和最大的两个个元素，与待排序起始位置和末尾位置进行交换，然后两头减小往中间靠拢，直到全部待排序的数据元素排完 。

在这里插入图片描述
2. 代码实现

//选择排序
//最坏：O(N^2)
//最好：O(N^2)
void SelectSort(int* a, int n)
{
	assert(a);
	//一次选一个最小的放在最前面
	//int left = 0;
	//int mini = 0;
	//while (left < n-1)
	//{
	//	mini = left;//left++后让mini赋值到未排序的数据中
	//	for (int i = left+1; i < n; i++)
	//	{
	//		if (a[i] < a[mini])
	//		{
	//			mini = i;
	//		}
	//	}
	//	Swap(&a[left], &a[mini]);
	//	left++;
	//}
	//一次选两个数，最小的放最左边，最大的放最右边，left++，right--后更新数组继续选
	int i = 0;
	int left = 0;
	int right = n - 1;
	int mini = 0;
	int maxi = 0;
	int flag = 0;
	while (left < right)
	{
		mini = left;
		maxi = left;//初始化mini和maxi为新排序序列第一个元素
		for (i = left + 1; i <= right; i++)
		{
			if (a[i] < a[mini])
			{
				mini = i;
			}
			if (a[i] > a[maxi])
			{
				maxi = i;
			}
		}
		Swap(&a[left], &a[mini]);
		//防止maxi与left重叠，需要修正
		if (maxi == left)
		{
			maxi = mini;
		}
		Swap(&a[right], &a[maxi]);
		left++;
		right--;
	}
}
int main()
{
	int a[] = { 10,8,5,2,4,6,7,3,2,5 };
	int n = sizeof(a) / sizeof(a[0]);
	SelectSort(a, n);
	for (int i = 0; i < n; i++)
	{
		printf("%d ", a[i]);
	}
	return 0;
}

特性总结：
3. 直接选择排序思考非常好理解，但是效率不是很好，实际中很少使用
4. 时间复杂度：最好：O(N2)，最坏：O(M2)
5. 空间复杂度：O(1)
6. 稳定性：不稳定

4.堆排序

  1. 排序思想：

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

在这里插入图片描述
2. 代码实现

void Swap(int* p1, int* p2)
{
	int tmp = *p1;
	*p1 = *p2;
	*p2 = tmp;
}
void AdjustUp(int* a, int child)
{
	assert(a);
	int parent = (child - 1) / 2;
	while (child > 0)
	{
		if (a[child] > a[parent])
		{
			Swap(&a[child], &a[parent]);
			child = parent;
			parent = (child - 1) / 2;
		}
		else
		{
			break;
		}
	}
}
void AdjustDown(int* a, int n, int parent)
{
	assert(a);
	//定义孩子的下标
	int child = parent * 2 + 1;
	while (child < n)//孩子在数组里面继续
	{
		//利用if条件判断选出两个孩子中大（小）的那一个
		if (child + 1 < n && a[child] < a[child + 1])//child+1<n 是为了防止数组越界，访问随机值。
		{
			child++;
		}
		//大堆中,如果父亲比孩子小，就把大的孩子与父亲进行交换；小堆则反之
		if (a[parent] < a[child])
		{
			Swap(&a[parent], &a[child]);
			parent = child;
			child = parent * 2 + 1;
		}
		else
		{
			break;
		}
	}
}
//堆排序
void HeapSort(int* a, int n)
{
	assert(a);
	int i = 0;;
	//向上调整建堆
	// O(N*longN)
	//for (i = 1; i < n; i++)
	//{
	//	AdjustUp(a, i);//传数组、数组尾元素的下标（child）
	//}
	//向下调整建堆
	//O(N)
	for (i = (n - 1 - 1) / 2; i >= 0; i--)//i=(n-1-1)/2代表父亲节点的下标，每次--，找到前一个父亲进行判断,直到根节点结束
	{
		AdjustDown(a, n, i);
	}

	//排序
	//O(N*longN)
	int end = n - 1;//最后一个元素的下标
	while (end > 0)
	{
		Swap(&a[0], &a[end]);//把最大的数据放在数组的最后
		//对交换后的数据进行调整，这里end也是要调整数组的大小
		AdjustDown(a, end, 0);
		end--;
	}
	//两倍的N*longN，所以在同量级的N*longN里比较慢
}
int main()
{
	int a[] = { 10,8,5,2,4,6,7,3,2,5 };
	int n = sizeof(a) / sizeof(a[0]);
	HeapSort(a, n);
	for (int i = 0; i < n; i++)
	{
		printf("%d ", a[i]);
	}
	return 0;
}

特性总结：

  1. 堆排序使用堆来选数，效率就高了很多。
  2. 时间复杂度：O(N*logN)
  3. 空间复杂度：O(1)
  4. 稳定性：不稳定

5.冒泡排序

  1. 排序思想：

相邻元素两两进行比较,一趟冒泡排序搞定一个元素，n个元素则通过(n-1)躺冒泡排序解决

在这里插入图片描述
2. 代码实现

//冒泡排序
//最好：O(N^2)
//最坏：O(N)
//思想：一趟冒泡排序搞定一个元素，n个元素则通过(n-1)躺冒泡排序解决
#include<stdio.h>
#include<assert.h>
#include<stdbool.h>
void Swap(int* p1, int* p2)
{
	int tmp = *p1;
	*p1 = *p2;
	*p2 = tmp;
}
void BubbleSort(int* a, int n)
{
	assert(a);
	int i = 0;
	int j = 0;
	bool exchange = false;
	//趟数
	for (i = 0; i < n - 1; i++)
	{
		//每一趟进行交换次数
		for (j = 0; j < n - 1 - i; j++)
		{
			//两两进行比较，大的交换到后面
			if (a[j] > a[j + 1])
			{
				Swap(&a[j], &a[j + 1]);
				exchange = true;
			}
		}
		if (exchange == false)
		{
			return;
		}
	}
}

int main()
{
	int a[] = { 10,8,5,2,4,6,7,3,2,5 };
	int n = sizeof(a) / sizeof(a[0]);
	BubbleSort(a, n);
	for (int i = 0; i < n; i++)
	{
		printf("%d ", a[i]);
	}
	return 0;
}

特性总结：

  1. 冒泡排序是一种非常容易理解的排序
  2. 时间复杂度：最坏：O(N2)，最好：O(N)（有序）
  3. 空间复杂度：O(1)
  4. 稳定性：稳定

6.快速排序

  1. 排序思想：

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

  1. 快排优化：
  1. 三数取中法选key
  2. 递归到小的子区间时，可以考虑使用插入排序

6.1hoare版本

在这里插入图片描述
代码实现：

void InsertSort(int* a, int n)
{
	for (int i = 1; i < n; i++)
	{
		int end = i - 1;//下标
		//首先保存要排序的数，一会就会被覆盖了
		int tmp = a[i];//插入的数据
		while (end >= 0)//下标控制循环
		{
			//小就往后挪动数据
			if (tmp < a[end])
			{
				a[end + 1] = a[end];
				end--;
			}
			else
			{
				break;
			}
		}
		a[end + 1] = tmp;//1、大的就直接往后放；2、小的往后挪break了或者不满足循环条件（最小数据，其它都往后挪）
	}
}
int GetMidNumi(int* a, int left, int right)
{
	int mid = (left + right) / 2;
	if (a[left] < a[mid])
	{
		if (a[mid] < a[right])
		{
			return mid;
		}
		else if (a[right] < a[left])
		{
			return left;
		}
		else
			return right;
	}
	else //a[left] > a[mid]
	{
		if (a[mid] > a[right])
		{
			return mid;
		}
		else if (a[right] > a[left])
		{
			return left;
		}
		else
			return right;
	}
}
void Swap(int* p1, int* p2)
{
	int tmp = *p1;
	*p1 = *p2;
	*p2 = tmp;
}
// 快速排序hoare版本
int PartSort1(int* a, int left, int right)
{
	//优化
	//随机选数
	//int randi = left + (rand() % (right - left));
	//Swap(&a[randi], &a[left]);

	//三数取中
	int midi = GetMidNumi(a, left, right);
	Swap(&a[midi], &a[left]);

	int keyi = left;
	while (left < right)
	{
		//右边找小
		while (left < right && a[right] >= a[keyi])//left<right防止left++、right--飘到数组外面
		{
			right--;
		}
		//左边找大
		while (left < right && a[left] <= a[keyi])
		{
			left++;
		}
		//把这两个位置的值进行交换
		Swap(&a[left], &a[right]);
	}
	Swap(&a[left], &a[keyi]);//相遇位置的值和keyi进行交换
	keyi = left;
	return keyi;
}
void QuickSort(int* a, int left, int right)
{
	if (left >= right)
	{
		return;
	}
	//小区间直接插入优化
	// 递归到这个区间进行判断是否使用插入
	//0~9十个数：9-0+1==10
	if ((right - left + 1) > 15)
	{
		int keyi = PartSort1(a, left, right);
		QuickSort(a, left, prev - 1);
		QuickSort(a, prev + 1, right);
	}
	else
	{
		//插入排序
		InsertSort(a + left, right - left + 1);
		//a + left是锁定要排序的区间，因为区间是在数组中任意位置的
	}

}
int main()
{
	int a[] = { 10,8,5,2,4,6,7,3,2,5 };
	int n = sizeof(a) / sizeof(a[0]);
	QuickSort(a, 0,n-1);
	for (int i = 0; i < n; i++)
	{
		printf("%d ", a[i]);
	}
	return 0;
}

6.2 挖坑法

在这里插入图片描述
代码实现：

void InsertSort(int* a, int n)
{
	for (int i = 1; i < n; i++)
	{
		int end = i - 1;//下标
		//首先保存要排序的数，一会就会被覆盖了
		int tmp = a[i];//插入的数据
		while (end >= 0)//下标控制循环
		{
			//小就往后挪动数据
			if (tmp < a[end])
			{
				a[end + 1] = a[end];
				end--;
			}
			else
			{
				break;
			}
		}
		a[end + 1] = tmp;//1、大的就直接往后放；2、小的往后挪break了或者不满足循环条件（最小数据，其它都往后挪）
	}
}
int GetMidNumi(int* a, int left, int right)
{
	int mid = (left + right) / 2;
	if (a[left] < a[mid])
	{
		if (a[mid] < a[right])
		{
			return mid;
		}
		else if (a[right] < a[left])
		{
			return left;
		}
		else
			return right;
	}
	else //a[left] > a[mid]
	{
		if (a[mid] > a[right])
		{
			return mid;
		}
		else if (a[right] > a[left])
		{
			return left;
		}
		else
			return right;
	}
}
void Swap(int* p1, int* p2)
{
	int tmp = *p1;
	*p1 = *p2;
	*p2 = tmp;
}
//挖坑法
int PartSort2(int* a, int left, int right)
{
	//优化
	//随机选数
	//int randi = left + (rand() % (right - left));
	//Swap(&a[randi], &a[left]);

	//三数取中
	int midi = GetMidNumi(a, left, right);
	Swap(&a[midi], &a[left]);
	//定义坑在最左边
	int hole = left;
	//记录key的值
	int key = a[left];
	while (left < right)
	{
		//数组从右边找小，找到小就把小换到坑里，并把坑位更新成小的那个地方
		while (left < right && a[right] >= key)//left<right防止left++、right--飘到数组外面
			right--;
		Swap(&a[hole], &a[right]);
		hole = right;
		//数组从左边找大，找到大就把大换到坑里，并把坑位更新成大的那个地方
		while (left < right && a[left] <= key)
			left++;
		Swap(&a[left], &a[hole]);
		hole = left;
	}
	a[hole] = key;//把key填到最后的坑里
	return hole;
	//PartSort2(a, begin, hole - 1);
	//PartSort2(a, hole + 1, end);
}
void QuickSort(int* a, int left, int right)
{
	if (left >= right)
	{
		return;
	}
	//小区间直接插入优化
	// 递归到这个区间进行判断是否使用插入
	//0~9十个数：9-0+1==10
	if ((right - left + 1) > 15)
	{
		int hole = PartSort2(a, left, right);
		QuickSort(a, left, prev - 1);
		QuickSort(a, prev + 1, right);
	}
	else
	{
		//插入排序
		InsertSort(a + left, right - left + 1);
		//a + left是锁定要排序的区间，因为区间是在数组中任意位置的
	}

}
int main()
{
	int a[] = { 10,8,5,2,4,6,7,3,2,5 };
	int n = sizeof(a) / sizeof(a[0]);
	QuickSort(a, 0,n-1);
	for (int i = 0; i < n; i++)
	{
		printf("%d ", a[i]);
	}
	return 0;
}

6.3 前后指针法

在这里插入图片描述
代码实现：

void InsertSort(int* a, int n)
{
	for (int i = 1; i < n; i++)
	{
		int end = i - 1;//下标
		//首先保存要排序的数，一会就会被覆盖了
		int tmp = a[i];//插入的数据
		while (end >= 0)//下标控制循环
		{
			//小就往后挪动数据
			if (tmp < a[end])
			{
				a[end + 1] = a[end];
				end--;
			}
			else
			{
				break;
			}
		}
		a[end + 1] = tmp;//1、大的就直接往后放；2、小的往后挪break了或者不满足循环条件（最小数据，其它都往后挪）
	}
}
int GetMidNumi(int* a, int left, int right)
{
	int mid = (left + right) / 2;
	if (a[left] < a[mid])
	{
		if (a[mid] < a[right])
		{
			return mid;
		}
		else if (a[right] < a[left])
		{
			return left;
		}
		else
			return right;
	}
	else //a[left] > a[mid]
	{
		if (a[mid] > a[right])
		{
			return mid;
		}
		else if (a[right] > a[left])
		{
			return left;
		}
		else
			return right;
	}
}
void Swap(int* p1, int* p2)
{
	int tmp = *p1;
	*p1 = *p2;
	*p2 = tmp;
}
//前后指针法
int PartSort3(int* a, int left, int right)
{
	//三数取中
	int midi = GetMidNumi(a, left, right);
	Swap(&a[midi], &a[left]);

	int prev = left;
	int cur = left + 1;
	int key = left;
	while (cur <= right)
	{
		//cur找到比key小的值，++prev，cur和prev位置的值交换，++cur
		if (a[cur] < a[key])
		{
			prev++;
			Swap(&a[prev], &a[cur]);
			cur++;
		}
		//cur的值比key要大，++cur
		else if (a[cur] >= a[key])
		{
			cur++;
		}
	}
	//循环结束，prev和key位置的值交换
	Swap(&a[prev], &a[key]);
	return prev;
}
void QuickSort(int* a, int left, int right)
{
	if (left >= right)
	{
		return;
	}
	//小区间直接插入优化
	// 递归到这个区间进行判断是否使用插入
	//0~9十个数：9-0+1==10
	if ((right - left + 1) > 15)
	{
		int prev = PartSort3(a, left, right);
		QuickSort(a, left, prev - 1);
		QuickSort(a, prev + 1, right);
	}
	else
	{
		//插入排序
		InsertSort(a + left, right - left + 1);
		//a + left是锁定要排序的区间，因为区间是在数组中任意位置的
	}

}
int main()
{
	int a[] = { 10,8,5,2,4,6,7,3,2,5 };
	int n = sizeof(a) / sizeof(a[0]);
	QuickSort(a, 0,n-1);
	for (int i = 0; i < n; i++)
	{
		printf("%d ", a[i]);
	}
	return 0;
}

6.4 快速排序（非递归）

  1. 排序思想：

借用栈辅助排序

  1. 栈里面去一段区间，单趟排序
  2. 单趟分割区间入栈
  3. 子区间只有一个值或者不存在就不入栈
  1. 代码实现：
void QuickSortNonR(int* a, int left, int right)
{
	ST st;
	STInit(&st);
	STPush(&st, right);
	STPush(&st, left);
	while (!STEmpty(&st))
	{
		//记录一段区间的首尾下标
		int begin = STTop(&st);
		STPop(&st);
		int end = STTop(&st);
		STPop(&st);
		//进行分割
		int midi = PartSort3(a, begin, end);
		//如果子区间只有一个值或者不存在就不入栈，反之入栈
		if (midi + 1 < end)
		{
			STPush(&st, end);
			STPush(&st, midi + 1);
		}
		if (begin < midi - 1)
		{
			STPush(&st, end);
			STPush(&st, midi + 1);
		}
	}

	STDestroy(&st);
}

特性总结：

  1. 快速排序整体的综合性能和使用场景都是比较好的，所以才敢叫快速排序
  2. 时间复杂度：最好：O(N*logN)，最坏：O(N2)
  3. 空间复杂度：O(logN)
  4. 稳定性：不稳定

7.归并排序

  1. 排序思想：

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

在这里插入图片描述
在这里插入图片描述
2. 代码实现

//递归子函数"区间"
void _MergeSort(int* a, int begin, int end, int* tmp)
{
	//返回条件(只有一个数就不递归了)
	if (begin >= end)
	{
		return;
	}
	//去中间数进行划分
	int mid = (begin + end) / 2;
	//[begin,mid] [mid+1,end]
	_MergeSort(a, begin, mid, tmp);
	_MergeSort(a, mid + 1, end, tmp);
	//将两段"区间"的数按大小依次尾插到临时数组
	int i = begin;//每段区间临时数组的下标
	int begin1 = begin, end1 = mid;
	int begin2 = mid + 1, end2 = end;
	//这里为升序;左闭右闭
	while (begin1 <= end1 && begin2 <= end2)
	{
		//如果两数相等就入第一个
		if (a[begin1] <= a[begin2])
		{
			tmp[i++] = a[begin1++];
		}
		if (a[begin1] > a[begin2])
		{
			tmp[i++] = a[begin2++];
		}
	}
	while (begin1 <= end1)
	{
		tmp[i++] = a[begin1++];
	}
	while (begin2 <= end2)
	{
		tmp[i++] = a[begin2++];
	}
	//归并好之后拷贝会原数组
	memcpy(a + begin, tmp + begin, sizeof(int) * (end - begin + 1));

}
//归并排序
void MergeSort(int* a, int n)
{
	//开辟一段临时空间用来存放数据
	int* tmp = (int*)malloc(sizeof(int) * n);
	if (tmp == NULL)
	{
		perror("malloc fail\n");
		return;
	}
	//用一个子函数进行递归的实现（不然每次都要malloc空间）
	_MergeSort(a, 0, n - 1, tmp);
	//释放空间
	free(tmp);
	tmp = NULL;

}
int main()
{
	int a[] = { 10,8,5,2,4,6,7,3,2,5,4 };
	int n = sizeof(a) / sizeof(a[0]);
	MergeSort(a, n);
	for (int i = 0; i < n; i++)
	{
		printf("%d ", a[i]);
	}
	return 0;
}

7.1归并排序（非递归）

  1. 排序思想：

非递归归并排序是一种基于分治思想的排序算法，采用将无序序列划分为若干个规模较小的、可以独立进行排序的子序列，然后将所以子序列归并，最终合成有序序列的排序方法

  1. 代码实现
void MergeSortNonR1(int* a, int n)//一把梭哈
{
	int* tmp = (int*)malloc(sizeof(int) * n);
	if (tmp == NULL)
	{
		perror("malloc fail\n");
		return;
	}
	//单趟--gap是几，每段区间就有几个数据
	int i = 0;
	int gap = 1;
	while (gap < n)
	{
		for (i = 0; i < n; i += 2 * gap)
		{
			//定义两段归并的区间
			int begin1 = i, end1 = i + gap - 1;
			int begin2 = i + gap, end2 = i + 2 * gap - 1;
			//printf("[%d][%d][%d][%d] ", begin1, end1, begin2, end2);
			//1.end1越界，不继续归并了
			if (end1 >= n)
			{
				//修正end1
				end1 = n - 1;
				//把begin2改为不存在的区间，避免多归并一个多余的值，造成tmp越界
				begin2 = n;
				end2 = n - 1;
			}
			//2.begin2越界，也不继续归并了
			else if (begin2 >= n)
			{
				begin2 = n;
				end2 = n - 1;
			}
			//3.end2越界了，修正end2，继续归并
			else if (end2 >= n)
			{
				end2 = n - 1;
			}
			//printf("[%d][%d][%d][%d] ", begin1, end1, begin2, end2);

			int j = i;//临时空间下标（tmp）
			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, tmp, sizeof(int) * n);
		gap *= 2;
		//printf("\n");
	}
	free(tmp);
	tmp = NULL;
}

void MergeSortNonR2(int* a, int n)//依次拷贝
{
	int* tmp = (int*)malloc(sizeof(int) * n);
	if (tmp == NULL)
	{
		perror("malloc fail\n");
		return;
	}
	//单趟--gap是几，每段区间就有几个数据
	int i = 0;
	int gap = 1;
	while (gap < n)
	{
		for (i = 0; i < n; i += 2 * gap)
		{
			//定义两段归并的区间
			int begin1 = i, end1 = i + gap - 1;
			int begin2 = i + gap, end2 = i + 2 * gap - 1;
			//printf("[%d][%d][%d][%d] ", begin1, end1, begin2, end2);
			//1.end1越界或者begin2越界，不继续归并了
			if (end1 >= n || begin2 >= n)
			{
				break;
			}
			//2.end2越界了，修正end2，继续归并
			else if (end2 >= n)
			{
				end2 = n - 1;
			}
			printf("[%d][%d][%d][%d] ", begin1, end1, begin2, end2);

			int j = i;//临时空间下标（tmp）
			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) * (2*gap)));
			//这样拷贝会导致栈的损坏
			memcpy(a + i, tmp + i, sizeof(int) * (end2 - i + 1));
		}
		gap *= 2;
		printf("\n");
	}
	free(tmp);
	tmp = NULL;
}
int main()
{
	int a[] = { 10,8,5,2,4,6,7,3,2,5,4 };
	int n = sizeof(a) / sizeof(a[0]);
	//两种方法，建议第二种（效率较高）
	//MergeSortNonR1(a, n);//一把拷贝（梭哈）
	MergeSortNonR2(a, n);//依次拷贝
	for (int i = 0; i < n; i++)
	{
		printf("%d ", a[i]);
	}
	return 0;
}

的特性总结：

  1. 归并的缺点在于需要O(N)的空间复杂度，归并排序的思考更多的是解决在磁盘中的外排序问题。
  2. 时间复杂度：O(N*logN)
  3. 空间复杂度：O(N)
  4. 稳定性：稳定

8.计数排序

  1. 排序思想：计数排序又称为鸽巢原理，是对哈希直接定址法的变形应用。 操作步骤：

统计相同元素出现次数
根据统计的结果将序列回收到原来的序列中

2.代码实现

void CountSort(int* a, int n)
{
	assert(a);
	//开辟n个数的空间
	int i = 0;
	/*int max = 0, min = 0;
	for (i = 0; i < n; i++)
	{
		if (a[i] > max)
		{
			max = a[i];
		}
		if (a[i] < min)
		{
			min = a[i];
		}
	}*///这种计算最大与最小的方法是错误的，因为数组里最小的数据可以比min要大
	//正确的应该是数组数据两两进行比较
	int max = a[0], min = a[0];
	for (i = 1; i < n; i++)
	{
		if (a[i] > max)
		{
			max = a[i];
		}
		if (a[i] < min)
		{
			min = a[i];
		}
	}
	int range = (max - min + 1);
	int* tmp = (int*)calloc(range, sizeof(int));
	assert(tmp);
	//统计出每个数据出现的次数
	for (i = 0; i < n; i++)
	{
		//tmp[a[i]]++;这种方式是错误的，会导致数组越界,
		//因为前面开辟的空间是范围空间大小，所以-min使得变成相对映射
		tmp[a[i] - min]++;
	}
	//排序
	int j = 0;//控制原数组下标
	for (i = 0; i < range; i++)//遍历统计次数数组
	{
		while (tmp[i]--)
		{
			a[j++] = i + min;
			//注意这里不要漏掉+min，
		}
	}

}
int main()
{
	int a[] = { 10,8,5,2,4,6,7,3,2,5,4 };
	int n = sizeof(a) / sizeof(a[0]);
	CountSort(a, n);
	for (int i = 0; i < n; i++)
	{
		printf("%d ", a[i]);
	}
	return 0;
}

特性总结：

  1. 计数排序在数据范围集中时，效率很高，但是适用范围及场景有限。
  2. 时间复杂度：O(MAX(N,范围))
  3. 空间复杂度：O(范围)
  4. 稳定性：稳定

9排序算法复杂度及稳定性分析

  1. 稳定性：假定在待排序的数据序列中，存在多个具有相同的关键字的记录，若经过排序，这些数据的相对次序保持不变，（相同数据相对位置变不变，变的不稳定，不变的稳定）即在原序列中，r[i]=r[j]，且r[i]在r[j]之前，而在排序后的序列中，r[i]仍在r[j]之前，则称这种排序算法是稳定的；否则称为不稳定的。
  2. 内部排序：数据元素全部放在内存中的排序。
  3. 外部排序：数据元素太多不能同时放在内存中，根据排序过程的要求不能在内外存之间移动数据的排序。

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

CC小师弟
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
数据结构——排序之冒泡排序
Renswc的博客
03-22 3896
冒泡排序（BubbleSort）是一种计算机科学领域的较简单的排序算法。它的基本思想是通过重复遍历待排序的数据集，并依次比较相邻的两个数据项，如果它们的顺序错误则进行交换。这个过程会持续重复直到所有相邻的数据项都已经交换完毕，此时说明该数据集已经排好序。冒泡排序的名称来源于排序过程中，较小的数据项会被逐渐“浮”到数组顶部，这个过程就像碳酸饮料中二氧化碳气泡最终会上浮到顶部的现象一样。因此，这种排序算法因其这一特性而得名。冒泡函数的核心思想。
数据结构—八大排序
热门推荐
想要上进的coder的博客
01-09 3万+
一、直接插入排序 void InsertSort(int* a, int n) { assert(a); for (int i = 0; i < n - 1; ++i) { int end = i; int x=a[end+1];//将end后面的值保存到x里面了 //将x插入到[0，end]的有序区间 while (end >= 0) { if (a[end] > x) { a[end + 1] = a[end]; //往后挪动一位
数据结构之排序及应用（实验）
12-14
数据结构之排序及应用（实验） 一、 排序算法介绍 排序算法是数据结构中非常重要的一部分，它们可以将无序的数据元素转换为有序的数据元素，从而提高数据的存储和检索效率。常见的排序算法有冒泡排序、选择排序、...
c语言 数据结构 快速排序算法
04-28
c语言版本的数据结构的快速排序算法，适用于新手学习
数据结构之排序课件(与“排序”有关文档共83张).pptx
11-30
数据结构中的排序是计算机科学中一个基础且重要的概念，它涉及到如何有效地组织和处理大量数据。排序算法的主要目标是将一组无序的数据按照特定规则（通常为升序或降序）进行排列。在这个课件中，主要介绍了几种常见...
数据结构排序.docx
04-16
数据结构上机：题目: 排序 输人10个整数，分别用希尔排序、快速排序、直接选择排序和归并排序实现由小到大排序并输出排序结果。
合并排序 数据结构 排序算法
12-22
合并排序 数据结构 排序算法
数据结构基础之快速排序
最新发布
02-25
快速排序是一种高效的排序算法，其核心思想是通过选取一个基准元素，将数组分割为两个子数组，其中左边的子数组元素都小于基准元素，右边的子数组元素都大于基准元素。然后递归地对左右子数组进行排序，直到整个数组...
数据结构排序算法
05-24
不稳定的排序算法：快速排序、希尔排序、堆排序、选择排序(简记：快些选堆)所需辅助空间最多：归并排序。所需辅助空间最少：堆排序。平均速度最快：快速排序。当n较大，则应采用时间复杂度为O(nlogn)的排序方法：...
数据结构快速排序算法的实现
12-21
快速排序算法c语言
C++数据结构排序算法
09-13
C++数据结构排序算法总结 在计算机科学中，排序算法是最基本和最重要的算法之一。在实际应用中，排序算法广泛应用于各种领域，如数据分析、机器学习、数据库管理等。C++数据结构排序算法总结将为您提供详细的排序...
数据结构：排序的运用
04-25
实现数据的折半插入排序、冒泡排序、快速排序和二路归并排序。 输入实例： 请输入待排序数据数目： 3 请输入待排序数据： 23,6,45 输出示例： 折半插入排序： 比较次数 移动元素次数 排序结果 6,23,45。
数据结构之排序向量类
05-22
排序向量类是数据结构的一种实现，通常用于管理一系列有序的数据。本文将深入探讨排序向量类的概念、工作原理以及它在实际应用中的价值。 排序向量类通常是一个类或结构体，它基于数组（向量）并提供了排序功能。在...
数据结构之选择排序
08-23
数据结构之选择排序
数据结构排序习题.md
01-16
数据结构--排序测试习题及答案，包含考试绝大部分题型
数据结构排序的ppt
03-04
数据结构与排序算法详解
"该资源是一份关于数据结构中排序算法的课件，主要涵盖了内部排序的各种方法，包括插入排序、快速排序、堆排序、归并排序、基数排序，并对各种排序方法进行了综合比较。此外，还讲解了排序的定义、内部排序与外部...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

CC小师弟

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

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

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

打赏作者

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

抵扣说明：

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

余额充值