快速排序算法的基本思想
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