快速排序的基本思想
快速排序使用分治的思想,通过一趟排序将待排序列分割成两部分,其中一部分记录的关键字均比另一部分记录的关键字小。之后分别对这两部分记录继续进行排序,以达到整个序列有序的目的。快速排序的三个步骤
1) 选择基准:在待排序列中,按照某种方式挑出一个元素,作为 “基准”(pivot);
2) 分割操作:以该基准在序列中的实际位置,把序列分成两个子序列。此时,在基准左边的元素都比该基准小,在基准右边的元素都比基准大;
3) 递归地对两个序列进行快速排序,直到序列为空或者只有一个元素;选择基准元的方式
对于分治算法,当每次划分时,算法若都能分成两个等长的子序列时,那么分治算法效率会达到最大。也就是说,基准的选择是很重要的。选择基准的方式决定了两个分割后两个子序列的长度,进而对整个算法的效率产生决定性影响。
<1>选取第一个数组元素为基准元
<2>选取数组元素中任一元素作为基准元
<3>选取数组中间元素作为基准元
一般来说,一般教材上将<1>作为样例。数据结构教材。作为数据结构当时没有入坑的人现在重新巩固快排算法。
从整体来说。
详细过程:
void qsort(int a[], int low, int high)
{
if(low >= high)
{
return;
}
int first = low;
int last = high;
int key = a[first];/*用字表的第一个记录作为枢轴*/
while(first < last)
{
while(first < last && a[last] >= key)
{
--last;
}
a[first] = a[last];/*将比第一个小的移到低端*/
while(first < last && a[first] <= key)
{
++first;
}
a[last] = a[first];
/*将比第一个大的移到高端*/
}
a[first] = key;/*枢轴记录到位*/
qsort(a, low, first-1);
qsort(a, first+1, high);
}
- 快排的实现
#include <iostream>
using namespace std;
void qsort(int a[], int low, int high)
{
if(low >= high)
{
return;
}
int first = low;
int last = high;
int key = a[first];
/*用字表的第一个记录作为枢轴*/
while(first < last)
{
while(first < last && a[last] >= key)
{
--last;
}
a[first] = a[last];
/*将比第一个小的移到低端*/
while(first < last && a[first] <= key)
{
++first;
}
a[last] = a[first];
/*将比第一个大的移到高端*/
}
a[first] = key;/*枢轴记录到位*/
qsort(a, low, first-1);
qsort(a, first+1, high);
}
int main()
{
int a[] = {57, 68, 59, 52, 72, 28, 96, 33, 24 , 99 ,11,100,167,258,999,778,123,11,258,93 };
qsort(a, 0, sizeof(a) / sizeof(a[0]) - 1);
for(int i = 0; i < sizeof(a) / sizeof(a[0]); i++)
{
cout << a[i] << " ";
}
return 0;
}
- 快排取不同基准元
/*三种方法进行比较*/
#include <iostream>
#include <stdlib.h>
using namespace std;
void Swap(int *arr, int index1, int index2)
{
int temp = arr[index1];
arr[index1] = arr[index2];
arr[index2] = temp;
}
int qsort(int *arr, int low, int high)
{
if(low>=high)
return 0;
int first = low;
int last = high;
int key = arr[low]; //取第一个元素作为基准元
while (first < last)
{
while (first < last && arr[last] >= key)
last--;
arr[first] = arr[last];
while (first < last && arr[first] <= key)
first++;
arr[last] = arr[first];
}
arr[first] = key; //基准元居中
return first;
}
void qsort_base(int *arr, int low, int high)
{
if (low >= high) return; //递归出口
int partition = qsort(arr, low, high);
if(partition==0) return;
qsort_base(arr, partition + 1, high);
}
void Partition_random(int *arr, int low, int high)
{
int rd=rand();
int index = rd% (high - low) + low; //取数组中随机下标
Swap(arr,index, low); //与第一个数交换
}
void qsort_random(int *arr, int low, int high)
{
if (low >= high)
return; //递归出口
Partition_random(arr, low, high); //随机基准元
int partition = qsort(arr, low, high); //将 >= x 的元素交换到右边区域,将 <= x 的元素交换到左边区域
qsort_random(arr, low, partition - 1);
qsort_random(arr, partition + 1, high);
}
void Partition_mid(int *arr, int low, int high)
{
int mid = low + (high + -low) / 2;
if (arr[mid] > arr[high])
Swap(arr, mid, high);
if (arr[low] > arr[high])
Swap(arr, low, high);
if (arr[mid] > arr[low])
Swap(arr, mid, low);
}
void qsort_mid(int *arr, int low, int high)
{
if (low >= high) return; //递归出口
Partition_mid(arr, low, high); //三数取中
int partition = qsort(arr, low, high);
qsort_mid(arr, low, partition - 1);
qsort_mid(arr, partition + 1, high);
}
int main()
{
int a[] = {57, 68, 52, 72, 28, 96, 33, 24 , 99 ,11,100,167,258,999,778,123,11,258 };
qsort_base(a, 0, sizeof(a) / sizeof(a[0]) - 1);
//qsort_random(a, 0, sizeof(a) / sizeof(a[0]) - 1);
//qsort_mid(a, 0, sizeof(a) / sizeof(a[0]) - 1);
for(int i = 0; i < sizeof(a) / sizeof(a[0]); i++)
{
cout << a[i] << " ";
}
return 0;
}
/*递归出口略有问题,仅供参考*/
- 时间复杂度分析
假设一次划分所得枢轴位置 i=k,则对n 个记录进行快排所需时间:
T(n) = Tpass(n) + T(k-1) + T(n-k)
其中 Tpass(n)为对 n 个记录进行一次划分所需时间。
若待排序列中记录的关键字是随机分布的,则 k 取 1 至 n 中任意一值的可能性相同。
结论: 快速排序的时间复杂度为O(nlogn)