数据结构：一篇拿捏十大排序(超详细版)

梦里梦外; 2024-02-22 09:46 9阅读 0赞

## ![0796b2f5a10c40be9ec5e05799479894.png][] ##

## 排序的概念： ##

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

## 插入排序： ##

>  **基本思想：**把待排序的记录按其关键码值的大小逐个插入到一个已经排好序的有序序列中，直到所有的记录插入完为止，得到一个新的有序序列 。**例如：**斗地主。

### 直接插入排序： ###

> 当插入第i(i>=1)个元素时，前面的array\[0\],array\[1\],…,array\[i-1\]已经排好序，此时用array\[i\]的排序码与array\[i-1\],array\[i-2\],…的排序码顺序进行比较，找到插入位置即将array\[i\]插入，原来位置上的元素顺序后移。

![3e95e688cf554868b0f9adedd03d7050.gif][]

#### 直接插入排序实现： ####

//直接插入排序
    //时间复杂度：O(n^2)  复杂度范围：O(n)-O(n^2)
    void InsertSort(int* a,int n)
    {
    	for (int i = 0; i < n - 1; i++)
    	{
    		int end = i;
    		int tmp = a[end + 1];
    		while (end >= 0)
    		{
    			if (a[end] > tmp)
    			{
    				a[end + 1] = a[end];
    			}
    			else
    			{
    				break;
    			}
    			end--;
    		}
    		a[end + 1] = tmp;
    	}
    }

> **直接插入排序的特性总结：**  
> 1. 元素集合越接近有序，直接插入排序算法的时间效率越高  
> 2. 时间复杂度：O(N^2)  
> 3. 空间复杂度：O(1)，它是一种稳定的排序算法  
> 4. 稳定性：稳定

### 希尔排序( 缩小增量排序 )： ###

> 希尔排序法又称缩小增量法。希尔排序法的**基本思想是**：先选定一个整数，把待排序文件中所有记录分成个组，所有距离为的记录分在同一组内，并对每一组内的记录进行排序。然后，重复上述分组和排序的工作。当到达=1时，所有记录在统一组内排好序。
> 
>  **预排序(gap>1)：**大的数更快的到后面去，小的数更快到前面，gap越大跳的越快，越不接近有序，gap越小跳的越慢，越接近有序，当gap=1时，完成排序。

![e0591ba8f97440e7b4490f627df5b128.png][]

//希尔排序
    //时间复杂度：O(nlogn)  复杂度范围：O(n^1.3)-O(nlogn)
    void ShellSort(int* a, int n)
    {
    	int gap = n;
    	while (gap > 1)
    	{
    		//gap = gap / 2;
    		gap = gap / 3 + 1;
    		for (int i = 0; i < n - gap; i++)
    		{
    			int end = i;
    			int tmp = a[i + gap];
    			while (end >= 0)
    			{
    				if (a[end] > tmp)
    				{
    					a[end + gap] = a[end];
    				}
    				else
    				{
    					break;
    				}
    				end -= gap;
    			}
    			a[gap + end] = tmp;
    		}
    	}
    }

> **希尔排序的特性总结：**  
> 1. 希尔排序是对直接插入排序的优化。  
> 2. 当gap > 1时都是预排序，目的是让数组更接近于有序。当gap == 1时，数组已经接近有序的了，这样就会很快。这样整体而言，可以达到优化的效果。我们实现后可以进行性能测试的对比。  
> 3. 希尔排序的时间复杂度不好计算，因为gap的取值方法很多，导致很难去计算，因此在好些树中给出的希尔排序的时间复杂度都不固定：
> 
> 《数据结构-用面相对象方法与C++描述》--- 殷人昆
> 
> ![d370b2c7fde04f91bd8c51bdc4dd5165.png][]
> 
> 因为咋们的gap是按照Knuth提出的方式取值的，而且Knuth进行了大量的试验统计，我们暂时就按照：O(n^1.25)到O(1.6^1.25)来算。  
> 4. 稳定性：不稳定

## 选择排序： ##

>  **基本思想：**每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，直到全部待排序的数据元素排完 。

### 直接选择排序： ###

> **基本思想：**
> 
> 1.在元素集合array\[i\]--array\[n-1\]中选择关键码最大(小)的数据元素  
> 2.若它不是这组元素中的最后一个(第一个)元素，则将它与这组元素中的最后一个（第一个）元素交换  
> 3.在剩余的array\[i\]--array\[n-2\]（array\[i+1\]--array\[n-1\]）集合中，重复上述步骤，直到集合剩余1个元素

![5c74d423d10941fa99327589998e2f04.gif][]

//直接选择排序
    //时间复杂度：O(n^2)  复杂度范围：O(n^2)-O(n^2)
    void Swap(int* p1, int* p2)
    {
    	int tmp = *p1;
    	*p1 = *p2;
    	*p2 = tmp;
    }
    
    void SelectSort(int* a, int n)
    {
    	int end = n - 1;
    	int begin = 0;
    	while (end > begin)
    	{
    		int maxi = begin;
    		int mini = begin;
    		for (int i = begin + 1; i <= end ; i++)
    		{
    			if (a[maxi] < a[i])
    			{
    				maxi = i;
    			}
    			if (a[mini] > a[i])
    			{
    				mini = i;
    			}
    		}
    		Swap(&a[maxi], &a[end]);
    		if (mini == end)
    		{
    			mini = maxi;
    		}
    		Swap(&a[mini], &a[begin]);
    
    		end--;
    		begin++;
    	}
    }

> **直接选择排序的特性总结：**  
> 1. 直接选择排序思考非常好理解，但是效率不是很好。实际中很少使用  
> 2. 时间复杂度：O(N^2)  
> 3. 空间复杂度：O(1)  
> 4. 稳定性：不稳定

### 堆排序： ###

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

![5a4caf049383447a94305a96c1fdda50.png][]

//堆排序
    //时间复杂度：O(nlogn)  复杂度范围：O(nlogn)-O(nlogn)
    //向下调整（此时建立大堆）
    void Swap(int* p1, int* 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] < a[child + 1])
    		{
    			child++;
    		}
    		if (a[parent] < a[child])
    		{
    			Swap(&a[child], &a[parent]);
    			parent = child;
    			child = (parent * 2) + 1;
    		}
    		else
    		{
    			break;
    		}
    	}
    }
    
    void HeapSort(int* a, int n)
    {
    	for (int i = (n - 1 - 1) / 2;i > 0;i--)
    	{
    		Adjustdown(a, n, i);
    	}
    
    	int end = n;
    	while (end > 0)
    	{
    		Swap(&a[0], &a[end - 1]);
    		Adjustdown(a, end - 1, 0);
    		end--;
    	}
    }

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

## 交换排序： ##

>  **基本思想：**所谓交换，就是根据序列中两个记录键值的比较结果来对换这两个记录在序列中的位置，交换排序的特点是：将键值较大的记录向序列的尾部移动，键值较小的记录向序列的前部移动。

### 冒泡排序： ###

> 每趟将最大的数排序到范围内最后一个位置，每趟结束后减少一个范围数，第二趟将次大的数排序到倒数第二个位置，当一趟排序没有改变数组顺序，说明排序完成，直接退出循环，否则依次排序完整个数组。

![5fe2d2f99e35414f90f8477404227439.gif][]

//冒泡排序
    //时间复杂度：O(n^2)  复杂度范围：O(n)-O(n^2)
    void Swap(int* p1, int* p2)
    {
    	int tmp = *p1;
    	*p1 = *p2;
    	*p2 = tmp;
    }
    
    void BubblingSort(int* a, int n)
    {
    	for (int i = 0; i < n; i++)
    	{
    		int change = 0;
    		for (int j = 1; j < n - i; j++)
    		{
    			if (a[j - 1] > a[j])
    			{
    				Swap(&a[j - 1], &a[j]);
    				change = 1;
    			}
    		}
    		if (change == 0)
    		{
    			break;
    		}
    	}
    }

> **冒泡排序的特性总结：**  
> 1. 冒泡排序是一种非常容易理解的排序  
> 2. 时间复杂度：O(N^2)  
> 3. 空间复杂度：O(1)  
> 4. 稳定性：稳定

### 快速排序： ###

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

#### hoare版本： ####

> 右边节点从右向左，如果节点的值大于或大于基元素(a\[right\] >= a\[key\])接着向左移动，否则到左边节点从左向右，如果节点的值小于或大于基元素(a\[left\] <= a\[key\])接着向右移动，都停止后，交换当前节点值，循环结束后，再将基元素与左节点交换。然后分治递归解决排序问题。
> 
> 注意(可能做的过程会遗漏问题)：
> 
> 1.当前节点与基节点比较要取等于号，否则节点值和基节点值相同时，会死循环；
> 
> 2.注意节点移动时考虑left < right,否则可能发生数组越界；

> **问：相遇位置比key小，怎么做到的?**  
> **答：**右边的先走的做到的。  
> **相遇情况分析:**  
> 1、R动L不动，去跟L相遇了（相遇位置是L的位置，L和R在上一轮交换过，交换以后L位置的值比key要小）
> 
> 2、L动R不动，去跟R相遇了（R先走，找大比key小的，停下来了，这时L找大没有找到跟R相遇了，相遇位置比key小）

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

![4bbff33b74ea439ba998572438d6775c.gif][]

//三数取中
    int Middle(int* a,int left, int right)
    {
    	int mid = (left + right) / 2;
    	if (a[left] > a[right])
    	{
    		if (a[left] > a[mid])
    		{
    			if (a[right] > a[mid])
    			{
    				return right;
    			}
    			else
    			{
    				return mid;
    			}
    		}
    		else
    		{
    			return left;
    		}
    	}
    	else
    	{
    		if (a[right] > a[mid])
    		{
    			if (a[left] > a[mid])
    			{
    				return left;
    			}
    			else
    			{
    				return mid;
    			}
    		}
    		else
    		{
    			return right;
    		}
    	}
    }
    //hoare方法
    int Hoare(int* a, int left, int right)
    {
    	int mid = Middle(a,left, right);
    	Swap(&a[left], &a[mid]);
    
    	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;
    }
    
    void QuickSort(int* a, int begin, int end)
    {
    	if (begin >= end)
    	{
    		return;
    	}
    
    	int key = Hoare(a, begin, end);
    	QuickSort(a, begin, key - 1);
    	QuickSort(a, key + 1, end);
    }

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

#### 挖坑法： ####

> 先将第一个元素存放在临时变量front中，形成一个坑位(空),然后重复hoare法的步骤，最终将存放元素与坑位填上。然后分治递归解决排序问题。

//三数取中
    int Middle(int* a,int left, int right)
    {
    	int mid = (left + right) / 2;
    	if (a[left] > a[right])
    	{
    		if (a[left] > a[mid])
    		{
    			if (a[right] > a[mid])
    			{
    				return right;
    			}
    			else
    			{
    				return mid;
    			}
    		}
    		else
    		{
    			return left;
    		}
    	}
    	else
    	{
    		if (a[right] > a[mid])
    		{
    			if (a[left] > a[mid])
    			{
    				return left;
    			}
    			else
    			{
    				return mid;
    			}
    		}
    		else
    		{
    			return right;
    		}
    	}
    }
    //挖坑法
    int Hold(int* a, int left, int right)
    {
    	int mid = Middle(a, left, right);
    	Swap(&a[left], &a[mid]);
    
    	int front = a[left];
    	int hold = left;
    
    	while (left < right)
    	{
    		while (left < right && a[right] >= front)
    		{
    			right--;
    		}
    		a[hold] = a[right];
    		hold = right;
    
    		while (left < right && a[left] <= front)
    		{
    			left++;
    		}
    		a[hold] = a[left];
    		hold = left;
    	}
    	a[hold] = front;
    	return hold;
    }
    
    void QuickSort(int* a, int begin, int end)
    {
    	if (begin >= end)
    	{
    		return;
    	}
    
    	int key = Hold(a, begin, end);
    	QuickSort(a, begin, key - 1);
    	QuickSort(a, key + 1, end);
    }

#### 上下指针法： ####

> 初始时，prev指针指向序列开头，cur指针指向prev指针的后一个位置，当a\[cur\] < a\[key\]且++prev != cur时，交换prev和cur节点，否则cur单独+1；循环结束后，开头与prev节点值交换。然后分治递归解决排序问题。

> 1cur找小，++prev，交换prev和cur的值  
> prev的有两种:  
> 1、在cur还没遇到比key大的值时候，prev紧跟着cur  
> 2、在cur还遇到比key大的值时候，prev在比key大的一组值的前面
> 
> 本质是把一段大于key的区间，推箱子似的往右推，同时小的甩到左边去

//三数取中
    int Middle(int* a,int left, int right)
    {
    	int mid = (left + right) / 2;
    	if (a[left] > a[right])
    	{
    		if (a[left] > a[mid])
    		{
    			if (a[right] > a[mid])
    			{
    				return right;
    			}
    			else
    			{
    				return mid;
    			}
    		}
    		else
    		{
    			return left;
    		}
    	}
    	else
    	{
    		if (a[right] > a[mid])
    		{
    			if (a[left] > a[mid])
    			{
    				return left;
    			}
    			else
    			{
    				return mid;
    			}
    		}
    		else
    		{
    			return right;
    		}
    	}
    }
    //上下指针法
    int Pointer(int* a, int left, int right)
    {
    	int mid = Middle(a, left, right);
    	Swap(&a[left], &a[mid]);
    
    	int key = left;
    	int prev = left;
    	int cur = left + 1;
    
    	while (cur <= right)
    	{
    		if (a[cur] < a[key] && ++prev != cur)
    		{
    			Swap(&a[prev], &a[cur]);
    		}
    		cur++;
    	}
    	Swap(&a[key], &a[prev]);
    	return prev;
    }
    void QuickSort(int* a, int begin, int end)
    {
    	if (begin >= end)
    	{
    		return;
    	}
    
    	int key = Pointer(a, begin, end);
    	QuickSort(a, begin, key - 1);
    	QuickSort(a, key + 1, end);
    }

#### 快速排序非递归实现： ####

int Pointer(int* a, int left, int right)
    {
    	int mid = Middle(a, left, right);
    	Swap(&a[left], &a[mid]);
    
    	int key = left;
    	int prev = left;
    	int cur = left + 1;
    
    	while (cur <= right)
    	{
    		if (a[cur] < a[key] && ++prev != cur)
    		{
    			Swap(&a[prev], &a[cur]);
    		}
    		cur++;
    	}
    	Swap(&a[key], &a[prev]);
    	return prev;
    }
    //快速排序非递归
    void QuickSortNonR(int* a, int begin, int end)
    {
    	SL sl;
    	SLInit(&sl);
    
    	SLPush(&sl, end);
    	SLPush(&sl, begin);
    
    	while (!SLEmpty(&sl))
    	{
    		int left = SLTTop(&sl);
    		SLPop(&sl);
    
    		int right = SLTTop(&sl);
    		SLPop(&sl);
    
    		int key = Pointer(a, left, right);
    		if (key + 1 < right)
    		{
    			SLPush(&sl, right);
    			SLPush(&sl, key + 1);
    		}
    		if (left < key - 1)
    		{
    			SLPush(&sl, key - 1);
    			SLPush(&sl, left);
    		}
    	}
    }

#### 快速排序(优化)： ####

> 当排序分治递归元素剩余十个的时候，直接插入排序来完成排序(剩余十个时还进行分治递归，多次递归有空间的浪费)。

void QuickSort2(int* a, int begin, int end)
    {
    	if (begin >= end)
    	{
    		return;
    	}
    	//优化：剩余十个时直接插入排序
    	if (end - begin + 1 > 10)
    	{
    		int key = Pointer(a, begin, end);
    		QuickSort2(a, begin, key - 1);
    		QuickSort2(a, key + 1, end);
    	}
    	else
    	{
    		InsertSort(a + begin,end - begin +1);
    	}
    }

## 归并排序： ##

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

![70ba2e4f0a694c7ca80c7d30489c21a7.png][]

//归并排序(递归)
    void _MergeSort(int* a,int* tmp,int begin,int end)
    {
    	if (begin >= end)
    	{
    		return;
    	}
    	int mid = (begin + end) / 2;
    
    	_MergeSort(a, tmp, begin, mid);
    	_MergeSort(a, tmp, mid + 1, end);
    
    	int begin1 = begin;
    	int end1 = mid;
    	int begin2 = mid + 1;
    	int end2 = end;
    	int cur = begin;
    	while (begin1 <= end1 && begin2 <= end2)
    	{
    		if (a[begin1] < a[begin2])
    		{
    			tmp[cur++] = a[begin1++];
    		}
    		else
    		{
    			tmp[cur++] = a[begin2++];
    		}
    	}
    	while (begin1 <= end1)
    	{
    		tmp[cur++] = a[begin1++];
    	}
    	while (begin2 <= end2)
    	{
    		tmp[cur++] = a[begin2++];
    	}
    
    	memcpy(a + begin, tmp + begin, (end - begin + 1) * sizeof(int));
    }
    
    //归并排序
    void MergeSort(int* a, int n)
    {
    	int* tmp = (int*)malloc(sizeof(int) * n);
    	if (tmp == NULL)
    	{
    		perror("malloc fail");
    		return;
    	}
    
    	_MergeSort(a, tmp, 0, n - 1);
    
    	free(tmp);
    }

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

### 归并排序非递归实现： ###

//归并排序非递归
    void MergeSortNonR(int* a, int n)
    {
    	int* tmp = (int*)malloc(sizeof(int) * n);
    	if (tmp == NULL)
    	{
    		perror("malloc fail");
    		return;
    	}
    
    	int gap = 1;
    	while (gap < n)
    	{
    		for (int i = 0; i < n; i += 2 * gap)
    		{
    			int begin1 = i;
    			int end1 = i + gap - 1;
    			int begin2 = i + gap;
    			int end2 = i + 2 * gap - 1;
    			int cur = i;
    
                if (begin2 > n - 1)
    			{
    				break;
    			}
    			if (end2 > n - 1)
    			{
    				end2 = n - 1;
    			}
    
    			while (begin1 <= end1 && begin2 <= end2)
    			{
    				if (a[begin1] < a[begin2])
    				{
    					tmp[cur++] = a[begin1++];
    				}
    				else
    				{
    					tmp[cur++] = a[begin2++];
    				}
    			}
    			while (begin1 <= end1)
    			{
    				tmp[cur++] = a[begin1++];
    			}
    			while (begin2 <= end2)
    			{
    				tmp[cur++] = a[begin2++];
    			}
    			memcpy(a + i, tmp + i, sizeof(int) * (end2 - i + 1));
    		}
    		gap *= 2;
    	}
    	free(tmp);
    }

## 非比较排序： ##

>  **基本思想：**计数排序又称为鸽巢原理，是对哈希直接定址法的变形应用。
> 
> 操作步骤：  
> 1. 统计相同元素出现次数  
> 2. 根据统计的结果将序列回收到原来的序列中

### 计数排序： ###

> 将每个元素有多少个，记录到一个数组中，然后从这个数组中依次遍历打印出来。

//计数排序
    void CountSort(int* a, int n)
    {
    	int max = a[0];
    	int 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*)calloc(range,sizeof(int));
    	if (count == NULL)
    	{
    		perror("ralloc fail");
    		return;
    	}
    
    	for (int i = 0; i < n; i++)
    	{
    		count[a[i] - min]++;
    	}
    
    	int j = 0;
    	for (int i = 0; i < range; i++)
    	{
    		while (count[i]--)
    		{
    			a[j++] = i + min;
    		}
    	}
    }

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

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

![587201bb65934a3aa9649a1a39480515.png][]

![aaa9e4d9ba5943c5b0a9dae48b087cb4.png][]

### 稳定性： ###

>  **稳定性：**指的是当未排序前，数组中有相同元素，在排序完成后没有改变相同元素的相对位置的情况下，说明该排序稳定。反之，不稳定。（考试分数相同，先交卷的在前面）
> 
> 例：
> 
>  **排序前：**2  **5** 9 6  **5** 3 7 1
> 
>  **排序后：**1 2 3  **5** **5** 6 7 9 说明此排序算法**稳定**！
> 
> 反之：排序后：1 2 3  **5****5** 6 7 9 说明此排序算法**不稳定**！

> **不稳定分析：**
> 
> **希尔排序：**预排序时，相同的元素分配到不同的组中。
> 
>  **选择排序：** 例：3 3 1 1;这种情况第一个3已经被交换位置。
> 
>  **堆排序：**例：9 8 9 6 2；这种情况按大堆排升序，第一个调换到最后以后就不稳定了。
> 
>  **快速排序：**例：5 8 5 4 5；这种因为相同所以没有去交换，到结束时第一个与left交换时不稳定。

## 扩展： ##

>  **因为以下排序，实用性低，除了考试以外，基本上不会进行考察，工作也基本用不上，就不多描述。**
> 
> 基数排序：按个，十，百，千位依次进行排序的算法。
> 
> 桶排序：

![902d7ec49cc94238adfecf0e3d60c566.png][]

#### 以上就是个人学习线性表的个人见解和学习的解析，欢迎各位大佬在评论区探讨！ ####

#### 感谢大佬们的一键三连！ 感谢大佬们的一键三连！ 感谢大佬们的一键三连！ ####

![7bad9f1ed1b44b53b34d043644d9965a.png][]

[0796b2f5a10c40be9ec5e05799479894.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/22/dc1282b997944784aa65418493d5b40c.png
[3e95e688cf554868b0f9adedd03d7050.gif]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/22/3663d1a4c6b949b9a7d6b3672c504510.png
[e0591ba8f97440e7b4490f627df5b128.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/22/6102d58eb9d64d8fb0687ac630826abf.png
[d370b2c7fde04f91bd8c51bdc4dd5165.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/22/3f143ed01bba48c8b5350efefd932ddf.png
[5c74d423d10941fa99327589998e2f04.gif]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/22/d4354346057e4f07a23e9b4db3de4479.png
[5a4caf049383447a94305a96c1fdda50.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/22/5dce8f7fc538471aaa5699ddad8c635c.png
[5fe2d2f99e35414f90f8477404227439.gif]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/22/eb74fd8cf89c477584bcf037117ecfee.png
[4bbff33b74ea439ba998572438d6775c.gif]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/22/bcf9cfa21af1462cbb0399bf60fdff34.png
[70ba2e4f0a694c7ca80c7d30489c21a7.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/22/44062123c34b438a814b534a96bfe259.png
[587201bb65934a3aa9649a1a39480515.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/22/e37922c4674540528cbc408e4317d9bf.png
[aaa9e4d9ba5943c5b0a9dae48b087cb4.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/22/fcda987bdf0b4e58b181fc4947372343.png
[902d7ec49cc94238adfecf0e3d60c566.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/22/d189a7b7e598437c8104a72c4540ee68.png
[7bad9f1ed1b44b53b34d043644d9965a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/22/add70fe3c34a4bb1ab0586a0fc0708c9.png