【数据结构】排序（快排，选择，直接插入，希尔）

目录

一.快速排序

1).快排的介绍.快排的介绍)

3).lomuto前后指针法.lomuto前后指针法)

4).非递归快排.非递归快排)

二.选择排序

---

一.快速排序

1).快排的介绍

快速排序是基于分治思想的经典交换排序算法，它选定一个元素作为基准值，通过双指针遍历将数组划分为两部分，使基准左侧元素全部小于等于它、右侧元素全部大于等于它，再递归对划分得到的左右子区间重复上述操作，不断缩小待排序范围，最终得到整体有序的数组，平均时间复杂度为 O (nlogn)，最坏情况下可达 O (n²)，属于不稳定排序。

2).Hoare快排

思路：

选取区间最左侧下标 keyi 作为基准位置 ，将 left 指针移到基准的下一位开始遍历；

在外层 left <= right 循环下，使 right 先移动 ，right 从区间右端向左遍历，当元素严格大于基准值时持续左移，直到找到小于或等于基准的元素停下。接着 left 从左向右遍历，当元素严格小于基准值时持续右移，直到找到大于或等于基准的元素停下；

若此时 left 和 right 尚未相遇，就交换两个指针指向的数组元素，同时使 right -- ，left ++ ；

当外层循环结束，说明 right = left，此时right 指向的就是基准元素应当存放的最终位置，交换原基准位置 keyi 与 right 位置的元素，将基准放置到它的有序位置，最后返回 right 下标，供外部递归函数划分左右子区间继续排序。

为什么 right / left 移动时，判断条件要严格大于 / 小于基准值？原因是如果条件为大于等于 / 小于等于，并且如果需要排序的数据相同或排列有序，算法的时间复杂度会从O(n * logn)变为O(n ^ 2)，大大提升所需时间。

借用网络流传图片理解：

代码如下:

//hoare版本
int _QuickSort1(int* arr, int left, int right)
{
	int keyi = left;
	++left;
	while (left <= right)
	{
		//right：从右往左走，找比基准值要小的
		while (left <= right && arr[right] > arr[keyi])
		{
			right--;
		}
		//left：从左往右走，找比基准值要大的
		while (left <= right && arr[left] < arr[keyi])
		{
			left++;
		}
		//right left 
		if (left <= right)
		{
			Swap(&arr[left++], &arr[right--]);
		}
	}
	Swap(&arr[keyi], &arr[right]);
	return right;
}


//快速排序
void QuickSort(int* arr, int left, int right)
{
	if (left >= right)
	{
		return;
	}
	//找基准值
	int keyi = _QuickSort(arr,left,right);
	//left keyi right
	//左序列[left,keyi-1]     右序列[keyi+1,right]
	QuickSort(arr, left, keyi - 1);
	QuickSort(arr, keyi + 1, right);
}

---

3).lomuto前后指针法.

lumoto前后指针法与之前顺序表算法题中的双指针思想异曲同工，如果掌握双指针，对lomuto前后指针法的理解就比较容易了，prev站岗，cur 探路。

思路：

选取区间最左侧元素作为基准，设置两个指针，prev 初始指向基准位置，cur 从基准的下一个位置开始向后遍历；

cur 不断向右遍历，一旦遇到小于基准值 的元素，就先将 prev 向后移动一位，如果 prev 和 cur 不重合，则交换两个指针指向的数据，把小元素往区间左侧聚拢；

当 cur 遍历完整个区间后，所有小于基准的元素都集中在 cur 的左边，最后交换基准位置与 prev 位置的元素，基准就落到它最终有序的位置，函数返回 prev 下标，用于递归划分左右子区间。

借用网络流传图片理解：

代码如下：

//lomuto前后指针法
int _QuickSort(int* arr, int left, int right)
{
	int keyi = left;
	int prev = left, cur = prev + 1;
	while (cur <= right)
	{
		if (arr[cur] < arr[keyi] && ++prev != cur)
		{
			Swap(&arr[prev], &arr[cur]);
		}
		cur++;
	}
	Swap(&arr[keyi], &arr[prev]);
	return prev;
}

//快速排序
void QuickSort(int* arr, int left, int right)
{
	if (left >= right)
	{
		return;
	}
	//找基准值
	int keyi = _QuickSort(arr,left,right);
	//left keyi right
	//左序列[left,keyi-1]     右序列[keyi+1,right]
	QuickSort(arr, left, keyi - 1);
	QuickSort(arr, keyi + 1, right);
}

---

4).非递归快排

非递归快排要借助数据结构栈/队列来存放数据，本文采取数据结构栈。

思路：

首先初始化栈，将待排序区间的 left和right先后入栈；

只要栈不为空，不断取出栈顶元素 begin 和end 对begin , end 区间执行 Lomuto 前后指针分区，得到基准元素的最终下标keyi；分区完成后，会产生左右两个子区间[begin, keyi‑1]和[keyi+1, end]，只有子区间内元素数量大于 1 时才将区间边界压入栈中，避免处理无效区间；循环不断取出栈中的区间重复分区操作，直到栈为空代表全部区间处理完毕，最后销毁栈完成排序。

代码如下：

//非递归版本的快速排序------栈
void QuicSortNoR(int* arr, int left, int right)
{
	ST st;
	StackInit(&st);
	StackPush(&st, left);
	StackPush(&st, right);
	while (!StackEmpty(&st))
	{
		//取栈顶两次
		int end = StackTop(&st);
		StackPop(&st);
		int begin = StackTop(&st);
		StackPop(&st);

		//[begin,end]找基准值
		int keyi = begin;
		int prev = begin, cur = prev + 1;
		while (cur <= end)
		{
			if (arr[cur] < arr[keyi] && ++prev != cur)
			{
				Swap(&arr[prev], &arr[cur]);
			}
			cur++;
		}
		Swap(&arr[keyi], &arr[prev]);
		keyi = prev;
		//begin keyi end
		//左序列：[begin,keyi-1]  右序列：[keyi+1,end];
		if (keyi + 1 < end)
		{
			StackPush(&st, keyi + 1);
			StackPush(&st, end);
		}
		if (begin < keyi - 1)
		{
			StackPush(&st, begin);
			StackPush(&st, keyi - 1);
		}
	}
	StackDestroy(&st);
}

---

二.选择排序

选择排序是一种简单直观的排序算法。它的工作原理是：第一次从待排序的数据元素中选出最小(或最大)的一个元素，存放在序列的起始位置，然后再从剩余的未排序元素中寻找最小(大)元素,将其放到已排序的序列的末尾。以此类 推,直到全部待排序的数据元素的个数为零。

借用网络流传图片理解：

代码如下：

void SelectSort(int* arr, int n)
{
	int begin = 0, end = n - 1;
	while (begin < end)
	{
		int maxi = begin;
		int mini = begin;
		for (int i = begin+1; i <= end; i++)
		{
			if (arr[i] < arr[mini])
			{
				mini = i;
			}
			if (arr[i] > arr[maxi])
			{
				maxi = i;
			}
		}
		//mini begin
		//maxi end
		if (maxi == begin)
		{
			maxi = mini;
		}
		Swap(&arr[mini], &arr[begin]);
		Swap(&arr[maxi], &arr[end]);
		begin++;
		end--;
	}
}

---

三.插入排序

直接插入排序把数组分为已排序区间 和未排序区间 ，初始时第一个元素作为已排序区间，后面全部元素属于未排序区间；依次取出未排序区间的第一个元素作为待插入元素，向前遍历已排序区间，把比待插入元素大的元素向后挪动腾出位置，找到合适的空位后将待插入元素放入，不断扩大有序区间，直到全部元素处理完成，整个数组就变为有序，它属于稳定排序，最好时间复杂度O(n)，最坏和平均时间复杂度O(n^2)。

具体步骤如下：

1. 从第二个元素开始，将其保存在一个临时变量中。
2. 向前遍历已排序序列，如果当前元素大于临时变量，将当前元素后移。
3. 如果找到小于或等于临时变量的位置，将临时变量插入到该位置。
4. 重复步骤 1 到 3，直到所有的元素都被插入到正确的位置。

借助网络流传图片理解：

代码如下：

//直接插入排序
void InsertSort(int* arr, int n)
{
	for (int i = 0; i < n - 1 ; i++)
	{
		int end = i;
		int tmp = arr[end + 1];
		while (end >= 0)
		{
			if (arr[end] > tmp)
			{
				arr[end + 1] = arr[end];
				end--;
			}
			else {
				break;
			}
		}
		arr[end + 1] = tmp;
	}
}

---

四.希尔排序

希尔排序是对直接插入排序的优化算法，它先设置一个gap（间隔） ，按照 gap 把数组分成若干组，对每一组分别执行直接插入排序，之后不断缩小 gap 的值，重复分组插入排序，当 gap 缩减为 1 时，就等价于普通的直接插入排序，此时数组已经基本接近有序，少量元素移动即可完成整体排序；希尔排序打破了直接插入排序一次只能移动一个位置的局限，让远距离的元素可以快速归位，提升排序效率，它是**不稳定排序，**最坏时间复杂度为 O (n²)。

具体代码逻辑如下：

1. 初始化间隔 gap 为数组长度 n。
2. 当 gap 大于 1 时，进行排序循环。
3. 更新 gap 的值为 gap 除以 3 后再加 1（这是希尔排序中推荐的一个常用间隔序列）。
4. 遍历数组，从索引 0 到索引 n - gap - 1。
5. 在每个遍历位置，记录当前索引为 end，同时记录 end + gap 处的元素值为 tmp。
6. 在当前位置进行比较和移动操作，如果当前位置的元素大于 tmp，则将当前元素后移 gap 个位置，并将 end 减去 gap。
7. 如果当前位置的元素小于等于 tmp，则跳出内层循环。
8. 将 tmp 插入到最终位置 end + gap 处。
9. 循环结束后，数组中的元素按照指定的间隔有序排列。

代码如下：

//希尔排序
void ShellSort(int* arr, int n)
{
	int gap = n;
	while (gap > 1)
	{
		gap = gap / 3 + 1;//3 2 1 
		//对每组进行直接插入排序
		for (int i = 0; i < n - gap; i++)
		{
			int end = i;
			int tmp = arr[end + gap];
			while (end >= 0)
			{
				if (arr[end] > tmp)
				{
					arr[end + gap] = arr[end];
					end -= gap;
				}
				else {
					break;
				}
			}
			arr[end + gap] = tmp;
		}
	}
}

---