排序算法之快速排序

快速排序算法的基本思想

        1．先从待排序元素数列中取出一个数作为基准值（一般取区间最后一个元素）。

        2．将待排序集合分割成两子序列，使左子序列中所有元素均小于基准值，右子序列中所有元素均大于基准值。（这样基准值的左边的没有大于key的，右边没有小于基准值的，只需对左右区间排序即可）

       3．再对左右区间重复第二步，直到各区间只有一个数。

 

快速排序之左右指针交换法

       快速排序的思路简单来说就是一趟快速排序下来，能够保证至少有一个数字到达它应该在的位置上。而后面的排序过程，这个数都不参与。

       在排序之前，首先确定一个值，这个值就是排序后到达其所属位置的值。然后定义两个指针，分别从头尾开始遍历，前面的找到一个比刚才那个值大的停止，后面的从后往前遍历，找到一个比刚才那个值小的停止，接着交换这两个值。周而复始，最终找到这个值的合适位置。

图解：

这个时候以 cur_value 左侧为一个新的区域，右侧也为一个新的区域继续进行排序，直至每个区域内元素只有一个，代表排序完毕。 

代码实现：

int Exchange(int arr[],int beg,int end)
{
	int cur_value = arr[end];  
	int left = beg;
	int right = end;
	while (left < right)
	{
		while (left < right && arr[left] <= cur_value) //找到比cur大的arr[left]
			left++;
		while (left < right && arr[right] >= cur_value)  //找到比cur小的arr[right]
			right--;
		if (left < right)
			Swap(&arr[left], &arr[right]);
	}
	if(left != end)
	   Swap(&arr[left], &arr[end]);                          //一趟排完末尾有序
	return left;
}
void _QuickSort(int arr[], int beg, int end)
{
	if (beg >= end)
		return;
	int mid = Exchange(arr, beg, end);
	_QuickSort(arr, beg, mid - 1);
	_QuickSort(arr, mid + 1, end);
}
void QucikSort(int arr[], int size)
{
	if (size <= 1)
		return;
	int beg, end;
	beg = 0;
	end = size - 1;
	_QuickSort(arr, beg, end);
}
-------test.c----------------
void test()
{
	int arr[] = { 9,5,2,7,4,3,8,6 };
    int sz = sizeof(arr) / sizeof(arr[0]);
	int i = 0;
	QucikSort(arr, sz);
	for (; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}
}
int main()
{
	test();
	system("pause");
	return;
}

 

快速排序之挖坑法

        挖坑法与左右指针交换法最大的区别就是，在左右进行遍历的时候，一旦找到一个比 cur_value 大的或小的就开始填坑，而这个坑就是你之前保存的 cur_value 的位置。

      图解：

所谓的挖坑法，就是相当于把上一个思路左右指针交换法中，在 right 查找到比 cur_value 大的值后停下，在 left 找到比 cur_value 小的值停下，此时交换 right 与 left 的这个过程，分步进行，之前是交换，现在变成了直接 “挖坑” “填坑” 的过程。

 

代码实现：

int undermine(int arr[], int beg, int end)
{
	int cur_value = arr[end];
	int left = beg;
	int right = end;
	while (left < right)
	{
		while (left < right && arr[left] <= cur_value) //从左往右找比基准值大的元素
			left++;
		if (left < right)
		{
			arr[right] = arr[left];
			right--;
		}
		while (left<right && arr[right] >= cur_value) //从右往左找比基准值小的元素
			right--;
		if (left < right)
		{
			arr[left] = arr[right];
			left++;
		}
	}
	arr[left] = cur_value;
	return left;
}
void _QuickSort(int arr[], int beg, int end)
{
	if (beg >= end)
		return;
	int mid = undermine(arr, beg, end);
	_QuickSort(arr, beg, mid - 1);
	_QuickSort(arr, mid + 1, end);
}
void QucikSort(int arr[], int size)
{
	if (size <= 1)
		return;
	int beg, end;
	beg = 0;
	end = size - 1;
	_QuickSort(arr, beg, end);
}


--------------------------------test.c--------------------------------
void test()
{
	int arr[] = { 9,5,2,7,4,3,8,6 };
    int sz = sizeof(arr) / sizeof(arr[0]);
	int i = 0;

	QucikSort(arr, sz);

	for (; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}
}
int main()
{
	test();
	system("pause");
	return;
}

快速排序之前后指针法

       该方法中两个指针均为从前往后开始遍历，也是快排三种方法中唯一可以排序单链表的方法。

       代码实现：

int exchange(int arr[], int beg, int end)
{
	int key_value = arr[end];
	int cur = beg;
	int prev = cur - 1;
	while (cur < end)
	{
		if (arr[cur] < key_value && ++prev != cur)
			Swap(&arr[cur], &arr[prev]);
		cur++;
	}
	if (++prev != end)
		Swap(&arr[prev], &arr[end]);
	return prev;
}
void _QuickSort(int arr[], int beg, int end)
{
	if (beg >= end)
		return;
	int mid = exchange(arr, beg, end);
	_QuickSort(arr, beg, mid - 1);
	_QuickSort(arr, mid + 1, end);
}
void QucikSort(int arr[], int size)
{
	if (size <= 1)
		return;
	int beg, end;
	beg = 0;
	end = size - 1;
	_QuickSort(arr, beg, end);
}

-------------------------test.c------------------------------
void test()
{
	int arr[] = { 9,5,2,7,4,3,8,6 };
    int sz = sizeof(arr) / sizeof(arr[0]);
	int i = 0;

	QucikSort(arr, sz);


	for (; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}
}
int main()
{
	test();
	system("pause");
	return;
}

总结

      1.快速排序的最好和最坏的场景：

                    ★最好场景：序列的中间值在末尾，此时排序过程类似二叉平衡树。时间复杂度为：O(N*logN)

                    ★最坏场景：序列原本已接近有序，此时排序过程类似单支树。时间复杂度为：O(N^2)

                     

针对最坏场景的解决方法：三数取中法：选择三个 cur_value 然后最终的值选择这三个当中中间的那个，这样的话我们选出的cur_value 一定不是整个区间的最值。由于快速排序需要递归或者是利用栈来实现，那么它的空间复杂度就高了，是 O (N)

      2.快速排序的空间复杂度：O(N*logN)

      3.快速排序的稳定性：不稳定

      4.快速排序的使用场景：数据量大，不能接近有序，数值随机，越乱越好

 

C++ STL中sort的实现： 

 https://blog.csdn.net/qq_35440678/article/details/80147601