快速排序算法 ( 挖坑法 ) ------- C语言

快速排序：

 

快速排序，在众多排序算法中有不可或缺的地位。

光听名字就知道，快速排序的时间复杂度应该是要优于其他算法的。

今天这篇博客将和大家一起学习快速排序算法的其中一种实现方法  >>  挖坑法

一、排序原理&逻辑

要想拿捏住快速排序算法，就要先将它的排序原理和逻辑给弄清楚。

我们现在有一组无序数据

创建一个变量 begin，使其指向数组的首元素；

创建一个变量 end，使其指向数组的最后一个元素；

创建一个变量 pivot ( 它就是那个 “坑” )，使其指向 begin 指向的元素；

创建一个变量 key，用于存放数据。 

| 原理&逻辑 |

①  取 begin 指向的元素存放在 key 中，此时 pivot 指向的位置会形成一个 “坑”

②  end 向左移动，直到找到比 key 小的数时停止，将 end 指向的数放到 “坑” ( pivot 指向的位置 ) 中，此时 end 指向的位置就产生了新的 “坑”，同时 pivot 指向 “坑” 的位置

③  begin 向右移动，直到找到比 key 大的数时停止，将 begin 指向的数放到 “坑” 中，此时 begin 指向的位置再一次产生新的 “坑”，同时 pivot 指向这个新的 “坑” 的位置

④  重复以上步骤，直到 begin 不再小于 end 时停止，此时 begin 和 end 指向同一给位置，同时将 pivot 指向 begin，最后将 key 放到 “坑” 里

| 图解 | 

>> 单个数排序图解

!! 此时 3 的顺序已经定了下来，后续不再需要移动 !!

| 代码实现 |

#include<stdio.h>

void ArrPrint(const int* a, int n)
{
	int i = 0;
	for (i = 0; i < n; i++)
	{
		printf("%d ", a[i]);
	}
}

void QuickSort(int* a, int n)
{
	int begin = 0;
	int end = n - 1;
	int pivot = begin;
	int key = a[begin];
	while (begin < end)
	{
		while (begin < end && a[end] >= key)
		{
			end--;
		}
		a[pivot] = a[end];
		pivot = end;
		while (begin < end && a[begin] <= key)
		{
			begin++;
		}
		a[pivot] = a[begin];
		pivot = begin;
	}
	pivot = begin;
	a[pivot] = key;
}

int main()
{
	int arr[] = { 3,1,6,5,0,4,2 };
	QuickSort(arr, sizeof(arr) / sizeof(arr[0]));
	ArrPrint(arr, sizeof(arr) / sizeof(arr[0]));
	return 0;
}

>> 代码运行符合图解分析，达到了我们预期的结果

我们重新将注意力放在图解上，会发现 3 的左边都是比 3 小的数，而 3 的右边都是大于 3 的数

当 3 左右两边的 x 区域和 y 区域都有序时，整个数组就变得有序了。

而对 x 区域的各个数和 y 区域的各个数排序与本篇博客上面讲解的对一个数排序的过程说相类似的。这时我们要运用到分治策略的思想。

二、分治策略

分治策略简而言之就是，将复杂问题化为多个类似的小问题，对这些小问题使用类似的方法进行解决。

在C语言里我们可以用函数的递归来实现分治策略。 用函数递归的形式不断的对 x 区域和 y 区域里的各个数进行排序，直到整个数组有序。

在上面的样例中，当我们将 3 放到了正确的位置上之后，我们要确立 x 区域和 y 区域

我们不妨创建一个变量 left 和一个变量 right 

变量 left 指向 x 区域 ( y 区域 ) 的左边界；

变量 right 指向 x 区域 ( y 区域 ) 的右边界；

>> 进行完以上的优化分析后，我们的代码同样也需要进行调整

#include<stdio.h>

void ArrPrint(const int* a, int n)
{
	int i = 0;
	for (i = 0; i < n; i++)
	{
		printf("%d ", a[i]);
	}
}

void QuickSort(int* a, int left, int right)   //讲解点1
{
	if (left >= right)   //讲解点3
	{
		return;
	}

	int begin = left;
	int end = right;
	int pivot = begin;
	int key = a[begin];
	while (begin < end)
	{
		while (begin < end && a[end] >= key)
		{
			end--;
		}
		a[pivot] = a[end];
		pivot = end;
		while (begin < end && a[begin] <= key)
		{
			begin++;
		}
		a[pivot] = a[begin];
		pivot = begin;
	}
	pivot = begin;
	a[pivot] = key;

	QuickSort(a, left, pivot - 1);   //讲解点2
	QuickSort(a, pivot + 1, right);   //讲解点2
}

int main()
{
	int arr[] = { 3,1,6,5,0,4,2 };
	QuickSort(arr, 0, (sizeof(arr) / sizeof(arr[0])) - 1);   // 讲解点1
	ArrPrint(arr, sizeof(arr) / sizeof(arr[0]));
	return 0;
}

| 讲解点1 |

| 讲解点2 | 

| 讲解点3 | 

三、“三数取中” ( 拓展 )

快速排序的平均时间复杂度为：O( n*logn )，这里我们就不展开讲解了

快速排序的最坏时间复杂度为：O( n^2 )，在什么情况下是最坏的呢？

 当待排序数组有序时，快速排序的时间复杂的最差

接下来我们将一起探讨这种最坏的情况以及如何优化我们的代码来解决这种情况

通常情况下我们取待排序区间的左边界的数据存放在 key 中，若该数组为有序数组 ( 以升序为例 ) 每次 end 都要从待排序区间的右边界遍历到左边界，这一操作会使得快速排序的时间复杂度变坏

| 图解 |

 为解决这一情况我们要引入一个较为巧妙的方法 >> “三数取中”

“三数取中”即取三个数中不是最大也不是最小的数

将这一概念引入快速排序中，若数组为有序数组 ( 以升序为例 )，则首元素为最小值，尾元素则为最大值，取首元素和尾元素的中间值作为待排序区间的 key 即可解决这一问题

| 逻辑 | 

①  创建变量 mid 用于指向中间值

②  比较 首元素 中间元素 尾元素 三者的大小，将 mid 指向中间值

③  交换 左边界 和 mid指向的数据 ( 鉴于习惯将待排序区间的左边界的数据存放在 key 中，这样做可以沿用已经写好的代码，仍然使用待排序区间左边界的数据当 key )

④  开始快速排序

>> 清楚 “三数取中” 的逻辑后，要用函数来实现三个数的比较

#include<stdio.h>

void ArrPrint(const int* a, int n)
{
	int i = 0;
	for (i = 0; i < n; i++)
	{
		printf("%d ", a[i]);
	}
}

void Swap(int* p1, int* p2)
{
	int tmp = *p1;
	*p1 = *p2;
	*p2 = tmp;
}

int GetMid(int* a, int left, int right)   //讲解点1
{
	int mid = (left + right) / 2;
	if (a[left] < a[mid])
	{
		if (a[mid] < a[right])
		{
			return mid;
		}
		else if (a[left] > a[right])
		{
			return left;
		}
		else
		{
			return right;
		}
	}
	else
	{
		if (a[mid] > a[right])
		{
			return mid;
		}
		else if (a[right] > a[left])
		{
			return left;
		}
		else
		{
			return right;
		}
	}
}

void QuickSort(int* a, int left, int right)
{
	if (left >= right)
	{
		return;
	}

	int index = GetMid(a, left, right);   //讲解点2
	Swap(&a[left], &a[index]);

	int begin = left;
	int end = right;
	int pivot = begin;
	int key = a[begin];
	while (begin < end)
	{
		while (begin < end && a[end] >= key)
		{
			end--;
		}
		a[pivot] = a[end];
		pivot = end;
		while (begin < end && a[begin] <= key)
		{
			begin++;
		}
		a[pivot] = a[begin];
		pivot = begin;
	}
	pivot = begin;
	a[pivot] = key;

	QuickSort(a, left, pivot - 1);
	QuickSort(a, pivot + 1, right);
}

int main()
{
	int arr[] = { 7,4,3,2,1,5,7,88,9,76,5 };
	QuickSort(arr, 0, (sizeof(arr) / sizeof(arr[0]))-1);
	ArrPrint(arr, sizeof(arr) / sizeof(arr[0]));
	return 0;
}

| 讲解点1 | 

| 讲解点2 | 

引入 “三数取中” 后有序数组的排序情况 >> 

可以看出引入“ 三数取中 ”后变量移动的次数比没有引入前少了11次！

< 本次学习就到这里了，如有错误希望大家指正，感谢 ! >