（数据结构初阶）排序

Zhang丶&｜！

已于 2022-09-23 23:16:26 修改

阅读量263

点赞数

分类专栏： C/C++学习笔记

于 2022-06-23 22:08:03 首次发布

本文链接：https://blog.csdn.net/qq_57594025/article/details/125406773

版权

C/C++学习笔记专栏收录该内容

41 篇文章 2 订阅

订阅专栏

1 直接插入排序

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

1.2 实现：

//插入排序
void InsertSort(int* a, int n)
{
	//多趟排序
	for (int i = 0; i < n - 1; i++)
	{
		int end = i;
		int temp=a[end+1];
		//把temp插入到[0,end]的有序区间
		while (end >= 0)
		{
			if (temp < a[end])
			{
				a[end + 1] = a[end];
				end--;
			}
			else
			{
				break;
			}
		}
		a[end + 1] = temp;
	}
}

1.3总结

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

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

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

④稳定性：稳定

2 希尔排序

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

2.2 实现：

//希尔排序
void ShellSort(int* a, int n)
{
	//gap>1时是预排序，gap==1时，为直接插入。
	int gap=n;
	while (gap > 1)
	{
		gap = (gap / 3+1);
		for (int i = 0; i < n - gap; ++i)
		{
			int end = i;
			int temp = a[end + gap];
			while (end >= 0)
			{
				if (temp < a[end])
				{
					a[end + gap] = a[end];
					end -= gap;
				}
				else
				{
					break;
				}
			}
			a[end + gap] = temp;
		}
	}
}

2.3总结

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

②当gap > 1时都是预排序，目的是让数组更接近于有序。当gap == 1时，数组已经接近有序的了，这样就会很快。这样整体而言，可以达到优化的效果。我们实现后可以进行性能测试的对比。

③希尔排序的时间复杂度不好计算，需要进行推导，推导出来平均时间复杂度： O(N^1.3—N^2）。

④稳定性：不稳定。

3 直接选择排序

3.1 基本思想： 每一次从待排序的数据元素中选出最小与最大的两个元素，存放在序列的起始位置与终止位置，直到全部待排序的数据元素排完。

3.2 代码实现

//直接选择排序
void SelectSort(int* a, int n)
{
	int left = 0, right = n-1;
	while (left < right)
	{   
		//选出最大的值和最小的值
		int minIndex = left, maxIndex = left;
		for (int i = left; i <= right; i++)
		{
			if (a[i] < a[minIndex])
				minIndex = i;

			if (a[i] > a[maxIndex])
				maxIndex = i;
		}

		Swap(&a[left],&a[minIndex]);

		//修正最大的值的位置
		if (left == maxIndex)
		{
			maxIndex = minIndex;
		}
		Swap(&a[right], &a[maxIndex]);
		right--;
		left++;
	}
}//直接选择排序
void SelectSort(int* a, int n)
{
	int left = 0, right = n-1;
	while (left < right)
	{   
		//选出最大的值和最小的值
		int minIndex = left, maxIndex = left;
		for (int i = left; i <= right; i++)
		{
			if (a[i] < a[minIndex])
				minIndex = i;

			if (a[i] > a[maxIndex])
				maxIndex = i;
		}

		Swap(&a[left],&a[minIndex]);

		//修正最大的值的位置
		if (left == maxIndex)
		{
			maxIndex = minIndex;
		}
		Swap(&a[right], &a[maxIndex]);
		right--;
		left++;
	}
}

3.3 特性总结：

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

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

③空间复杂度：O(1) 。

④稳定性：不稳定

4 堆排序

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

4.2 代码实现：

//向下调整算法
void AdjustDown(int* a, int n, int parent)
{
	int child = parent * 2 + 1;
	while (child < n)
	{
		//找出左右孩子中大的那一个（建立小堆只需要找到孩子中小的那个）
		if (child + 1 < n && a[child] < a[child + 1])
		{
			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)
{
	//建堆（时间复杂度O(N)。）
	for (int i = (n - 1 - 1) / 2; i >= 0; i--)
	{
		AdjustDown(a, n, i);
	}
	int end = n - 1;
	while (end > 0)
	{
		Swap(&a[0], &a[end]);
		//选出次大的(顺序没乱，向下调整即可),时间复杂度O(logN)。
		AdjustDown(a, end, 0);
		end--;
	}
}

4.3 特性总结：

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

②时间复杂度：O(N*logN) 。

③ 空间复杂度：O(1) 。

④ 稳定性：不稳定。

5 冒泡排序

5.1 概念：根据序列中两个记录键值的比较结果来对换这两个记录在序列中的位置，将键值较大的记录向序列的尾部移动，键值较小的记录向序列的前部移

5.2 代码实现：

//冒泡排序
void BubbleSort(int* a, int n)
{
	for (int i = 0; i < n - 1; i++)
	{
        int exchange = 0;
		for (int j = 0; j < n - i - 1; j++)
		{
			if (a[j] > a[j + 1])
			{
				int temp = a[j];
				a[j] = a[j + 1];
				a[j + 1] = temp;
                exchange =1;
			}
		}
        if(exchange == 0;)
        {
            break;
        }
	}
}

5.3 特性总结：

① 冒泡排序是一种非常容易理解的排序。

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

③ 空间复杂度：O(1)。

④ 稳定性：稳定。

6 快速排序

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

6.2 代码实现：

//快排优化一：三数取中。
int GetMidIndex(int* a, int left, int right)
{
	//移位运算比除法运算效率高
	int mid = (left + right) >> 1;
	if (a[left] < a[mid])
	{
		if (a[mid] < a[right])
		{
			return mid;
		}
		else if (a[left] > a[right])
		{
			return left;
		}
		else
		{
			return right;
		}
	}
	else // a[left] >= a[mid]
	{
		if (a[mid] > a[right])
		{
			return mid;
		}
		else if (a[left] < a[right])
		{
			return left;
		}
		else
		{
			return right;
		}
	}
}
//单趟排序(hoare法 或 左右指针法)
int PartSort1(int* a, int left, int right)
{
	//三数取中优化
	int MidIndex = GetMidIndex(a,left,right);
	Swap(&a[MidIndex], &a[left]);

	int key = left;
	while (left < right)
	{
		//找小
		while (left < right && a[right] >= a[key])
		{
			right--;
		}
		//找大
		while (left < right && a[left] <= a[key])
		{
			left++;
		}
		Swap(&a[left], &a[right]);
	}
	Swap(&a[key], &a[left]);

	return left;
}
//单趟排序(挖坑法)
int PartSort2(int* a, int left, int right)
{
	//三数取中优化
	int MidIndex = GetMidIndex(a, left, right);
	Swap(&a[MidIndex], &a[left]);

	int key = a[left];
	while (left < right)
	{
		//找小
		while (left < right && a[right] >= key)
		{
			right--;
		}
		//找到后，放入坑位中
		a[left] = a[right];

		//找大
		while (left < right && a[left] <= key)
		{
			left++;
		}
		//找到后，放入坑位中
		a[right] = a[left];
	}
	//相遇，结束单趟，将key放入正确的位置
	a[left] = key;
	return left;
}
//单趟排序(前后指针法)
int PartSort3(int* a, int left, int right)
{
	//三数取中优化
	int MidIndex = GetMidIndex(a, left, right);
	Swap(&a[MidIndex], &a[left]);

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

//快速排序
void QuickSort(int* a, int begin,int end)
{
	if (begin >= end)
	{
		return;
	}

	//1、如果这个子区间数据较多，继续选key单趟，分割子区间分治递归。
	//2、如果这个子区间数据较少，继续分治递归不划算。
	if (end - begin > 10)
	{
		int keyi = PartSort3(a, begin, end); //选择三种方法之一
		//排好KEY位置数，分数列为[begin,keyi-1] 与 [keyi+1,end] 两部分。 
		QuickSort(a, begin, keyi - 1);
		QuickSort(a, keyi + 1, end);
	}
	else //小区间优化(当数据较少时，直接插入排序，不再进行递归)
	{
		InsertSort(a + begin, end - begin + 1);
	}
}


//非递归
//递归：现代编译器优化很好，性能已经不是大问题了
//最大的问题是递归深度太深，导致栈溢出。
///只能改成非递归，改成非递归有两种方法：
//1、直接改成循环->斐波那契数列求解
//2、树遍历非递归和快排非递归等等，只能用Stack存储数据，模拟递归过程。
//[begin,end]
void QuickSortNonR(int* a, int begin, int end)
{
	Stack 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 keyi = PartSort3(a, left, right);
		if (left < keyi - 1)
		{
			StackPush(&st, left);
			StackPush(&st, keyi-1);
		}
		if (right > keyi + 1)
		{
			StackPush(&st, keyi + 1);
			StackPush(&st, right);
		}
	}
	StackDestroy(&st);
}

6.3 特性总结：

①快速排序整体的综合性能和使用场景都是比较好的，所以才敢叫快速排序。

② 时间复杂度：O(N*logN) 。

③空间复杂度：O(logN) ~ O(N）。

④稳定性：不稳定。

⑤单趟排序：选出一个key,一般是最左边的，或者最右边的，将key放到正确的位置上去，左边的比key小，右边的比key大。选最左边的值做key，right先走，right找小，left找大，然后交换left与right的值，直到left和right相遇。

7 归并排序

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

7.2 代码实现：

//归并
void _Merge(int*a,int* temp,int begin1,int end1,int begin2,int end2)
{
	int i = begin1;
	int j = begin1;
	while (begin1 <= end1 && begin2 <= end2)
	{
		if (a[begin1] < a[begin2])
			temp[i++] = a[begin1++];
		else
			temp[i++] = a[begin2++];
	}
	//判断哪个子区间还没结束
	while (begin1 <= end1)
		temp[i++] = a[begin1++];
	while (begin2 <= end2)
		temp[i++] = a[begin2++];

	//归并完成后，拷贝回原数组
	for (; j <= end2; j++)
		a[j] = temp[j];
}
//归并排序子函数（主函数开了空间，不方便递归）
void _MergeSort(int* a, int left, int right, int* temp)
{
	if (left >= right)
		return;

	int mid = (left + right) >> 1;
	//[left,mid]  [mid+1,right]
	_MergeSort(a, left, mid, temp);
	_MergeSort(a, mid+1, right, temp);

	//两段有序子区间归并到temp，并且拷贝回去。
	//int begin1 = left, end1 = mid;
	//int begin2 = mid + 1, end2 = right;
	_Merge(a,temp, left,mid,mid+1,right);
}
//归并排序
void MergeSort(int* a, int n)
{
	int* temp = (int*)malloc(sizeof(int) * n);
	if (temp == NULL)
	{
		printf("malloc fail\n");
		exit(-1);
	}
	_MergeSort(a, 0, n - 1,temp);
	free(temp);
}
//归并排序（非递归）
void MergeSortNonR(int* a, int n)
{
	int* temp = (int*)malloc(sizeof(int) * n);
	if (temp == NULL)
	{
		printf("malloc fail\n");
		exit(-1);
	}
	int gap = 1;
	while (gap < n)
	{
		for (int i = 0; i < n; i += 2 * gap)
		{   
			//小区间[i,i+gap-1][i+gap,i+2*gap-1] 归并
			int begin1 = i, end1 = i + gap - 1, begin2 = i + gap, end2 = i + 2 * gap - 1;

			//如果最后一个小组归并时，第一个小区间不够gap个和第二个小区间不存在就都不需要归并了
			if (begin2 >= n)
				break;

			//如果最后一个小组归并时，第二个小区间存在，但是不够gap个，会导致结束位置越界，需要修正
			if (end2 >= n)
				end2 = n - 1;

			_Merge(a, temp, begin1, end1, begin2, end2);
		}
		gap *= 2;
	}
	free(temp);
}

7.3 特性总结：

①归并的缺点在于需要O(N)的空间复杂度，归并排序的思考更多的是解决在磁盘中的外排序问题。

② 时间复杂度：O(N*logN)。

③ 空间复杂度：O(N)。

④ 稳定性：稳定。

8 计数排序

8.1 概念：计数排序又称为鸽巢原理，是对哈希直接定址法的变形应用。操作步骤： ①统计相同元素出现次数。②根据统计的结果将序列回收到原来的序列中。

8.2 代码实现：

//计数排序(只适合一组数据，数据的值比较集中)
void CountSort(int* a, int n)
{
	//找出数据中的最大最小值
	int max = a[0], min = a[0];
	for (int i = 0; i < n; i++)
	{
		if (a[i] > max)
			max = a[i];
		if (a[i] < min)
			min = a[i];
	}
	//求出需要开辟的计数数组的大小
	int range = max - min + 1;

	int* count = (int*)malloc(sizeof(int) * range);
	if (count == NULL)
	{
		printf("malloc fail\n");
		exit(-1);
	}
	memset(count, 0, sizeof(int) * range);
	//遍历计数(相对映射)
	for (int i = 0; i < n; i++)
	{
		count[a[i] - min]++;
	}
	//对应写回，即排好序
	int i = 0;
	for (int j = 0; j < range; j++)
	{
		while (count[j]--)
		{
			a[i++] = j + min;
		}
	}
    free(count);
}

8.3 特性总结：

①计数排序在数据范围集中时，效率很高，但是适用范围及场景有限。

②时间复杂度：O(MAX(N,range))。

③空间复杂度：O(range)。

④ 稳定性：稳定

9 总结

9.1 稳定：数组中的值，排完序后，相对位置不变，那么就是稳定的，否则就不是。

9.1.1 冒泡、插入、归并是稳定的，其他都不稳定。

Zhang丶&｜！

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
（数据结构初阶）排序

目录1 直接插入排序2 希尔排序3 直接选择排序4 堆排序5 冒泡排序6 快速排序7 归并排序8 计数排序9 总结1.1 概念：直接插入排序是一种简单的插入排序法，其基本思想是：把待排序的记录按其关键码值的大小逐个插入到一个已经排好序的有序序列中，直到所有的记录插入完为止，得到一个新的有序序列。 1.2 实现：1.3总结 ①元素集合越接近有序，直接插入排序算法的时间效率越高。②时间复杂度：O(N^2)。③ 空间复杂度：O(1)，它是一种稳定的排序算法。④稳定性：稳定2.1 概念：希尔排序法又称缩小
复制链接

扫一扫