【数据结构】排序（2）

最新推荐文章于 2024-05-17 23:32:03 发布
最新推荐文章于 2024-05-17 23:32:03 发布
阅读量1.3k 收藏 22
点赞数 25
分类专栏： 数据结构 文章标签： 数据结构 排序算法 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2302_76142697/article/details/136185864
版权

目录

一、快速排序：

1、hoare(霍尔)版本：

2、挖坑法：

3、前后指针法：

4、非递归实现快速排序：

二、归并排序：

1、递归实现归并排序：

2、非递归实现归并排序： 

三、排序算法整体总结：

一、快速排序：

基本思想：

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

1、hoare(霍尔)版本：

运用递归原理，定义一个keyi（基准值），然后左找大，右找小，然后递归基准值的左右区间。 

具体思路：

  1. 选定一个基准值，可以是a[0] / a[Size-1]。
  2. 确定两个指针 left 和 right 分别从左边和右边向中间遍历数组。
  3. 例如：选最左边的为基准值则right先走，遇到比基准值大的就停下，然后left走，遇到比基准值小的就停下，然后交换left与right位置对应的值。（如果以最右边为基准值，则left先走，right后走）
  4. 重复以上步骤，直到left = right ，最后将基准值与left(right)位置的值交换。

这样下来基准值所在的位置就是它排序后正确所在的位置，因为左边的所有数都比他小，右边的所有数都比他大。

然后再递归以基准值为界限的左右两个区间中的数，当区间中没有元素时，排序完成。

代码实现：

// 三数选中位数返回下标，作为一个快排的小优化，(不用也可以，不影响后面的代码)
int GetMedian(int* a, int begin, int end)
{
	int midi = (begin + end) / 2;
	// begin end midi三个数选中位数
	if (a[begin] < a[midi])
	{
		if (a[midi] < a[end])
			return midi;
		else if (a[begin] > a[end])
			return begin;
		else
			return end;
	}
	else
	{
		if (a[end] > a[begin])
			return begin;
		else if (a[midi] > a[end])
			return midi;
		else
			return end;
	}
}

// hoare（霍尔）方法
int PartSort1(int* a, int begin, int end)// begin end 为下标
{
	int median = GetMedian(a, begin, end);// 选中位数返回下标

	swap(a[median], a[begin]); // 这里的swap使用的是库函数中写好了的，
                              // 使用自己写的注意形参与实参

	int left = begin, right = end;
	int keyi = begin;
	while (left < right)
	{
		// 右边找小
		while (left<right && a[right] >= a[keyi])
		{
			right--;
		}

		// 左边找大
		while (left < right && a[left] <= a[keyi])
		{
			left++;
		}
		swap(a[left], a[right]);
	}

	// 交换基准值和 left与right 交汇位置的值
	swap(a[left], a[keyi]);

	// 返回基准值的下标
	return left;
}

void QuickSort(int* a, int begin, int end) // begin end 为下标
{
	if (begin >= end)
	{
		return;
	}

	int keyi = PartSort1(a, begin, end);	

	// 继续递归keyi（已排好序的值）的左右区间
	QuickSort(a, begin, keyi - 1);
	QuickSort(a, keyi + 1, end);
}

2、挖坑法：

具体思路：

  1. 从最左边选定一个基准值取出，然后这个位置就为“坑”。
  2. 还是运用左右指针，当右指针遇到比基准值小的值时，将该值放入坑中，然后右指针指向的位置就是新的“坑”，然后移动左指针，当左指针遇到比基准值大的值时，同样将该值放入坑中，然后左指针指向的位置就是新的“坑”，然后再移动右指针，以此反复直到左右指针相遇。
  3. 当左右指针相遇时，将基准值放入最后的“坑”中。

然后再递归以基准值为界限的左右两个区间中的数，当区间中没有元素时，排序完成。

 代码实现：

int PartSort1(int* a, int begin, int end)// begin end 为下标
{
	int median = GetMedian(a, begin, end);// 选中位数返回下标

	swap(a[median], a[begin]); // 这里的swap使用的是库函数中写好了的，
                              // 使用自己写的注意形参与实参

	int left = begin, right = end;
	int keyi = begin;
	while (left < right)
	{
		// 右边找小
		while (left<right && a[right] >= a[keyi])
		{
			right--;
		}

		// 左边找大
		while (left < right && a[left] <= a[keyi])
		{
			left++;
		}
		swap(a[left], a[right]);
	}

	// 交换基准值和 left与right 交汇位置的值
	swap(a[left], a[keyi]);

	// 返回基准值的下标
	return left;
}

// 挖坑法
int PartSort2(int* a, int begin, int end)
{
	int median = GetMedian(a, begin, end);// 选中位数返回下标

	swap(a[median], a[begin]); // 这里的swap使用的是库函数中写好了的，
	// 使用自己写的注意形参与实参

	// 定义基准值与“坑位”
	int keyi = a[begin];
	int hole = begin;

	// begin 与 end 充当左右指针
	while (begin < end)
	{
		// 右边找小，填到左边的坑
		while (begin < end && a[end] >= keyi)
		{
			end--;
		}

		// 填坑
		a[hole] = a[end];
		hole = end;

		// 左边找大，填到右边的坑
		while (begin < end && a[begin] <= keyi)
		{
			begin++;
		}

		// 填坑
		a[hole] = a[begin];
		hole = begin;
	}
	a[hole] = keyi;
	return hole;
}

void QuickSort(int* a, int begin, int end) // begin end 为下标
{
	if (begin >= end)
	{
		return;
	}

	int keyi = PartSort2(a, begin, end);	

	// 继续递归keyi（已排好序的值）的左右区间
	QuickSort(a, begin, keyi - 1);
	QuickSort(a, keyi + 1, end);
}

3、前后指针法：

具体思路：

  1. 定义一个基准值key，指针 prev 和 cur。（cur = prev + 1）
  2. cur先走，遇到比key大的值，++cur。
  3. cur遇到比key小的值，++prev，交换prev和cur位置的值。
  4. 以此反复直到cur走出数组范围。

  5. 最后交换key和prev的值

然后再递归以基准值为界限的左右两个区间中的数，当区间中没有元素时，排序完成。

代码实现：

int PartSort3(int* a, int begin, int end)
{
	int median = GetMedian(a, begin, end);// 选中位数返回下标

	swap(a[median], a[begin]); // 这里的swap使用的是库函数中写好了的，
	// 使用自己写的注意形参与实参

	// 定义基准值、前后指针
	int keyi = begin;

	int prev = begin, cur = prev + 1;

	while (cur <= end)
	{
		// 保留keyi下标的值
		if (a[cur] < a[keyi] && ++prev != cur)// 避免自己给自己赋值的情况,
		{
			swap(a[prev], a[cur]);
		}
		++cur;
	}

	swap(a[prev], a[keyi]);

	// 因为交换了位置，所以下标prev的位置才是基准值
	return prev;
}

void QuickSort(int* a, int begin, int end) // begin end 为下标
{
	if (begin >= end)
	{
		return;
	}

	int keyi = PartSort3(a, begin, end);	

	// 继续递归keyi（已排好序的值）的左右区间
	QuickSort(a, begin, keyi - 1);
	QuickSort(a, keyi + 1, end);
}

4、非递归实现快速排序：

非递归实现快速排序就需要运用到栈，栈中存放的是需要排序的左右区间。其大致思想是与递归实现的思路类似。

具体思路：

  1. 将待排序数组的左右下标入栈。
  2. 若栈不为空，分两次取出栈顶元素，分为闭区间的左右界限。
  3. 将区间中的元素按照【上述三种方法（霍尔、挖坑、前后指针）的任意一种】得到基准值的位置
  4. 再以基准值为界限，当基准值左右区间中有元素，将区间入栈

然后重复上述步骤直到栈中没有元素时，排序完成。

代码实现：

void QuickSortNonr(int* a, int begin, int end)
{
	// 这里使用的是C++标准模板库的stack，如果是C语言的话需手搓一个栈出来
	// 但基本的思路是一样的，这里为了方便就不手搓哩

	// 定义一个栈并初始化
	stack<int> s;

	// 将数组的左右下标入栈
	s.push(end);
	s.push(begin);

	// 当栈不为空时，继续排序
	while (!s.empty())
	{
		int left = s.top();
		s.pop();
		int right = s.top();
		s.pop();

		// 获取基准值的位置（下标）
		int keyi = PartSort1(a, left, right);
		// [left, keyi-1] keyi [keyi+1, right]

		// 以基准值为界限，若基准值左右区间中有元素，则将区间入栈
		if (left < keyi - 1)
		{
			s.push(keyi - 1);
			s.push(left);
		}

		if (keyi + 1 < right)
		{
			s.push(right);
			s.push(keyi + 1);
		}
	}
	// 如果是手搓的栈，记得释放内存
}

快速排序的特性总结：

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

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

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

  4. 稳定性：不稳定

二、归并排序：

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

基本思想：

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

本质为：

依次将数组划分，直到每个序列中只有一个数字。一个数字默认有序，然后再依次合并排序。

1、递归实现归并排序：

代码实现：

void _MergeSort(int* a, int begin, int end, int* tmp)
{
	// 当区间中没有元素时将不再进行合并
	if (begin >= end)
	{
		return;
	}
	
	// 划分数组，进行递归操作
	int mid = (begin + end) / 2;
	
	_MergeSort(a, begin, mid, tmp);		// 划分左区间
	_MergeSort(a, mid + 1, end, tmp); // 划分右区间

	// 两个有序序列进行合并
	int begin1 = begin, end1 = mid;
	int begin2 = mid + 1, end2 = end;
	int i = begin;
	while (begin1 <= end1 && begin2 <= end2)// 结束条件为一个序列为空就停止。
	{
		if (a[begin1] < a[begin2])
		{
			tmp[i++] = a[begin1++];
		}
		else
		{
			tmp[i++] = a[begin2++];
		}
	}

	// 进行上一步的操作后会有一个有序序列不为空，将其合并进tmp
	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 Size)
{
	//因为需要将两个有序序列进行合并，所以需要开辟相同空间
	int* tmp = (int*)malloc(sizeof(int) * Size);
	assert(tmp);

	_MergeSort(a, 0, Size - 1, tmp);
	free(tmp);
}

2、非递归实现归并排序： 

非递归实现的思想与递归实现的思想是类似的，但序列划分过程和递归是相反的，并不是每次一分为二， 而是先拆分为一个元素一组、再两个元素一组进行排序、再四个元素一组进行排序....以此类推，直到将所有的元素排序完。

代码实现：

void MergeSortNonR(int* a, int Size)
{
	int* tmp = (int*)malloc(sizeof(int) * Size);
	assert(tmp);

	// 先将元素拆为一个一组
	int gap = 1;
	while (gap < Size) // 当gap=Size时就是一组序列
	{
		// 每两组进行一个合并排序
		int index = 0; // 记录tmp数组中元素的下标
		for (int i = 0; i < Size; i += 2 * gap)// 两组中元素的个数为2*gap
		{
			// 控制两组的边界
			int begin1 = i, end1 = i + gap - 1;
			int begin2 = i + gap, end2 = i + 2 * gap - 1;

			// 当原数组中元素个数不是2^n时，最后两组会出现元素不匹配的情况

			// 情况1: 当 end1 >= Size 或 begin2 >= Size 时即最后两组元素只剩下一组时不需要进行合并排序
			if (end1 >= Size || begin2 >= Size)
			{
				break;
			}

			// 情况2: end2 >= Size 时，即最后两组中，第二组的元素个数小于第一组，则需要调整第二组的边界
			if (end2 >= Size)
			{
				end2 = Size - 1;
			}

			// 进行合并排序
			while (begin1 <= end1 && begin2 <= end2)
			{
				if (a[begin1] < a[begin2])
				{
					tmp[index++] = a[begin1++];
				}
				else
				{
					tmp[index++] = a[begin2++];
				}
			}

			while (begin1 <= end1)
			{
				tmp[index++] = a[begin1++];
			}

			while (begin2 <= end2)
			{
				tmp[index++] = a[begin2++];
			}

			//一趟排序完后，将有序序列拷贝到原数组中
			memcpy(a, tmp, sizeof(int) * index);
		}

		// 更新gap变为二倍
		gap *= 2;
	}
	free(tmp);
	tmp = NULL;
}

归并排序的特性总结：

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

三、排序算法整体总结：

   稳定性：指数组中相同元素在排序后相对位置不发生变化。

 补充：

 1、在希尔排序中，增量的选择会影响其时间复杂度。

 2、序列初始顺序在一些算法中也会影响其时间复杂度。

枫挽月
关注
  • 25
    点赞
  • 踩
  • 22
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构排序2
12-28
希尔排序 交换排序：冒泡排序，快速排序 选择排序：简单选择排序，堆排序
【数据结构】八大排序(超详解+附动图+源码)
热门推荐
Edward_Asia的博客
11-21 7万+
前言 所谓排序，就是使一串记录，按照其中的某个或某些关键字的大小，递增或递减的排列起来的操作。 生活中各种地方都需要用到排序，所以学好排序算法是非常重要的。 排序分为 内部排序 和 外部排序。 内部排序：数据元素全部放在内存中的排序。外部排序：数据元素太多不能同时放在内存中，根据排序过程的要求不能在内外存之间移动数据的排序。 这部分主要是内部排序。排序讲解都以升序为例。 常见的排序算法： // 排序实现的接口 // 插入排序 void InsertSort(int* arr..
数据结构—八大排序
想要上进的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]; //往后挪动一位
数据结构——排序总结
m0_52711790的博客
12-14 2913
一、排序的概念 排序是计算机内经常进行的一种操作，其目的是将一组“无序”的记录序列调整为“有序”的记录序列。（递增或递减） 二、排序的分类 一图以蔽之： 三、交换排序（省略冒泡） 1、概念 快速排序： 又称划分交换排序（partition-exchange sort），简称快排，一种排序算法，最早由东尼·霍尔提出。在平均状况下，排序n个项目要 O(n log2 n)（大O符号）次比较。在最坏状况下则需要 O(n^2)次比较，但这种状况并不常见。事实上，快速排序 (n lo...
《数据结构》八大排序（详细图文分析讲解）
1
11-27 1万+
可能这是最适合你学习的八大排序的博客，通俗易懂的思路讲解
数据结构——【排序】详解
Lucky_mzc的博客
03-14 6750
一. 排序💨 1.1 基本概念 排序（sorting）又称分类，就是将一组任意序列得数据元素按一定得规律进行排列（按照其中的某个或某些关键字的大小，递增或递减的排列起来的操作），使之成为有序序列。 平时的上下文中，如果提到排序，通常指的是排升序（非降序）。 通常意义上的排序，都是指的原地排序(in place sort)。 1.2 稳定性 定义：数组 arr 中有若干元素，其中 A元素和 B元素相等，并且 A元素在 B元素前面，如果使用某种排序算法排序后，能够保证 A元素依然在 B元素的前面，可
数据结构排序学习总结
guoquanqin的博客
03-20 2224
排序算法执行效率的分析，从这几个方面来衡量 1. 最好情况、最坏情况、平均情况时间复杂度 2. 时间复杂度的系数、常数 、低阶 3. 比较次数和交换（或移动）次数 原地排序（Sorted in place）。原地排序算法，就是特指空间复杂度是 O(1) 的排序算法 排序算法的稳定性：如果待排序的序列中存在值相等的元素，经过排序之后，相等元素之间原有的先后顺序不变，如果两个 3 的前后顺序没有改变，那我们就把这种排序算法叫作稳定的排序算法 冒泡排序（Bubble Sort） 冒...
数据结构之折半插入排序
&volume的博客
08-12 2581
作者简介：大家好我是小唐同学(๑>؂
【数据结构】图解七大排序
waywt1的博客
12-06 2万+
七大排序的可视化
数据结构实验报告六 排序
G_M_R_的博客
12-31 8038
数据结构实验报告：实验六 排序
数据结构——拓扑排序
cdz2470的博客
07-16 4188
AOV网（ActivityOnVertexNetwork），AOV是一个有向无环图（Directedacyclicgraph），简称DAG。当这大事足够复杂时，也就是说分成的小事足够多时，我们需要理清思路，找到一个好的方法，来决定事情的先后。也就是说我们不可能完成，找工作之前要有一定的经验，而攒经验之前要找到工作，这实在是矛盾的很。这是一个有环图，我们发现这个环中的结点入度都不为0，因此我们不能找到其一个拓扑排序。比如说，我们上厕所，必须要先拿上手纸（如果你说你不用拿，那当我没说）。......
数据结构排序.docx
04-16
数据结构上机：题目: 排序 输人10个整数，分别用希尔排序、快速排序、直接选择排序和归并排序实现由小到大排序并输出排序结果。
合并排序 数据结构 排序算法
12-22
合并排序 数据结构 排序算法
数据结构 排序 思考题2
01-08
全部每周作业和视频思考题答案和解析 见 浙江大学 数据结构 思考题+每周练习答案 题目一：在堆排序中，元素下标从0开始。则对于下标为i的元素，其左、右孩子的下标分别为： A. 2i-1, 2i B. 2i, 2i+1 C. 2i+1, 2i+2...
数据结构排序算法
05-24
不稳定的排序算法：快速排序、希尔排序、堆排序、选择排序(简记：快些选堆)所需辅助空间最多：归并排序。所需辅助空间最少：堆排序。平均速度最快：快速排序。当n较大，则应采用时间复杂度为O(nlogn)的排序方法：...
数据结构 | 详解栈实现队列&队列实现栈
最新发布
mooridy的博客
05-17 327
step2：此时非空队列中剩下的唯一一个数就是“栈顶”元素，使用QueueFront进行·取值后，直接进行QueuePop删除。step0.先利用假设法假定非空队列notempty和空队列empty，再利用MyStackEmpty函数对进行修正。step1:将notempty队列中的前size-1个元素依次push到empty队列中，再进行删除，实现移动操作。
USB3.0接口——（2）数据结构
dkmknjk的博客
05-14 1064
在 USB 3.0 及更高版本的 xHCI 协议中，"Rings"、"Transfer Request Block (TRB)" 和 "Transfer Descriptor (TD)" 是用于管理 USB 数据传输和事件的重要概念。
「探索数据结构：了解顺序表」
2301_80321602的博客
05-17 528
顺序表是一种线性表的存储结构，它是由一组物理地址连续的存储单元（通常是数组）依次存储线性表中的元素。顺序表中的元素在内存中是连续存储的，通过元素在数组中的下标来访问和操作元素。顺序表的优点是访问元素的时间复杂度为O(1)，即可以通过下标直接访问元素，操作效率高；缺点是插入和删除元素时需要移动其他元素，时间复杂度为O(n)，效率较低。首先，我们需要定义动态顺序表的数据类型SLDataType和结构体SeqList。动态顺序表使用数组arr存储数据，size表示当前有效数据个数，capacity。
“ 树 ” 的概念
2401_82669797的博客
05-14 688
通常的方法是链表中每个结点由三个域组成，数据域和左右指针域，左右指针分别用来给出该结点左孩子和右孩子所在的链结点的存储地址。树是一种非线性的数据结构，它是由n（n>=0）个有限结点组成一个具有层次关系的集合。：若一个结点含有子结点，则这个结点称为其子结点的父结点；：以某结点为根的子树中任一结点都称为该结点的子孙。：一个结点含有的子树的根结点称为该结点的子结点；具有相同父结点的结点互称为兄弟结点；：一个结点含有的子树的个数称为该结点的度；：从根开始定义起，根为第1层，根的子结点为第2层，以此类推；
数据结构排序交换排序
08-26
交换排序是一种基于比较的排序...这两种交换排序算法都是比较简单但不是非常高效的排序算法，特别是在处理大规模数据时。对于需要更高效的排序算法，可以考虑使用其他的排序算法，例如归并排序、堆排序或基数排序等。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值