快速排序:
空间复杂度 :O(logn)-O(n)
时间复杂度 :O(nlogn)-O(n^2)
稳定性: 快速排序是不稳定的排序算法 2 2 1 排完之后相对顺序发生了变化
只适用于数组排序。
前面提到的 直接插入排序、冒泡排序、希尔排序、在元素有序或者说基本有序的情况下,时间复杂度为O(n).
而快速排序跟其他的几种排序算法恰恰相反, 快速排序在元素有序或者逆序的情况下,时间复杂度最糟糕为O(n^2).而在元素随机、或者说找的元素接近基准元素时、此种情况下时间复杂度能达到O(nlogn)量级。
所以针对快速排序有两种优化思路:
1.取待排序数组中 头、中、尾三个位置的元素、取中间值作为基准元素。(此种方式最好,递归调用栈的深度最低)
2.随机选一个元素作为基准元素。
还有一个问题,就是当数组中存在大量重复元素时,大量的重复元素被分到了基准的一边,导致数组严重失去平衡,这样会导致递归调用栈深度增加,从而导致快排的时间复杂度变为O(n^2).
针对此种问题的优化思路:
1.使用两路快排进行优化(此种方式会将相同元素均衡的分配到数组两边)
两路快排虽然不会导致数组失衡,但是针对大量重复元素进行排序,显然没有必要。并且也会增加递归调用栈的深度。
针对此种问题的优化思路:
1.三路快排(只针对非重复元素进行排序,对重复元素不予理睬)。
所以快排的终极思路是:
1.利用随机数、头中尾取中元素法保证针对有序或者基本有序序列,快排的时间复杂度不至于退化为O(n^2).
2.采用三路快排解决数组中存在大量重复元素的问题。
代码展示:
#include<stdio.h>
#include<stdlib.h>
#define random(x) (rand()%x)
#include <time.h>
/*
快速排序:
空间复杂度 :O(logn)-O(n) --> 空间复杂度本质上就是递归层数
时间复杂度 :O(nlogn)-O(n^2) --> 时间复杂地本质上是 O(n*递归层数)
稳定性: 快速排序是不稳定的排序算法 2 2 1 排完之后相对顺序发生了变化
只适用于数组排序。
要想知道快速排序的递归层数、那么首先我们首先就根据每次确定的基准以及左右子表,确定出一棵基准二叉树.该二叉树的深度就是递归的层数。
我们知道二叉树的深度h在 log2n - n 之前。 所以 快速排序的时间复杂度从O(n*logn)-O(n^2).
*/
//返回快速排序枢轴的下标
int partition(int a[],int low,int high){
//第一个元素作为枢轴
int pivot = a[low];
//用low、high搜索枢轴的最终位置
while(low < high){
//从high所指元素往前找,找到一个比基准小的元素进行交换
while(low < high && a[high] >= pivot) high--;
a[low]=a[high];
//从low所指元素往后找,找到一个比基准大的元素进行交换
while(low < high && a[low]<= pivot) low ++;
a[high]=a[low];
}
//枢轴元素存放到最终位置
a[low]=pivot;
//返回存放枢轴的最终位置
return low;
}
//交换两个下标中元素的值
void swap(int a[],int index1,int index2){
int temp = a[index1];
a[index1] = a[index2];
a[index2]=temp;
}
//知道为什么此种交换方式在快排中会出错了, 因为i可能会和j+1重合, 此时这种交换方式是不适用的,
/*
1 12 43 28 16 23 32
low 指向 43, j = 43 i从low下一个位置开始往后遍历 i = 28 小于 43 ,需要交换
此时其实 j+1 和 i 指向的其实是一个位置,都是28。
如果此时用这种交换方式
a[j+1]= a[i]+a[j+1]=56;
a[i]=[j+1]-a[i]=56-56=0;
a[j+1]=a[j+1]-a[i]= 0-0=0;
所以此种交换方式不可取
*/
void swap2(int a[],int index1,int index2){
a[index1]=a[index1]+a[index2];
a[index2]=a[index1]-a[index2];
a[index1]=a[index1]-a[index2];
}
//快速排序的第二种思路: 一个下标搞定基准元素要插入的位置
int partition2(int a[],int low ,int end){
int j = low;
int pivot = a[low];
for(int i=low+1 ;i <= end;i++){
//需要将元素移到前面去 (与基准元素相等的元素我们都放到了基准元素的左边)
if(a[i] <= pivot){
swap(a,j+1,i);
j++;
}
}
//将枢轴元素放到正确的位置上
swap(a,j,low);
return j;
}
/*
当数组中元素有序、基本有序时,快速排序的效率最低
所以针对快速排序的优化:
1.随机选待排数组中的一个元素作为基准元素。
2.选头、中、尾 三个元素、 选取中间的元素作为基准元素。
这样即使当数组中元素有序、基本有序时,快速排序的递归调用栈不至于太深。
*/
//随机选待排数组中的一个元素作为基准元素
int partition3(int a[], int low ,int high){
srand((int)time(NULL));
int index = random((high-low+1));
//将index位置的元素交换到开头
swap(a,low,low+index);
int pivot = a[low];
while(low<high){
while(low<high && a[high]>=pivot) high--;
a[low]=a[high];
while(low<high && a[low]<= pivot) low++;
a[high]=a[low];
}
a[low]=pivot;
return low;
}
//选头、中、尾三个元素、选取中间的元素作为基准元素
int partition4(int a[],int low,int high){
int mid = (low+high)/2;
//计算出三个数中的最大值
int max=a[low] > a[mid] ? a[low]:a[mid];
max=a[high]>max?a[high]:max;
//计算出三个数中的最小值
int min=a[low] < a[mid] ? a[low]:a[mid];
min=a[high] <min ?a[high]:min;
//中间值
int middle = a[mid]+a[low]+a[high]-max-min;
if(middle != a[low]){
if(middle == a[mid]){
swap(a,low,mid);
}else{
swap(a,low,high);
}
}
int pivot = a[low];
int j = low;
for(int i = low + 1; i <= high ; i++){
if(a[i] <= pivot){
swap(a,j+1,i);
//j++不能少
j++;
}
}
swap(a,j,low);
return j;
}
/*
如果排序序列中重复元素太多, 会导致一次分割会产生两个极不平衡的子序列。 --> 这样也会导致快排的递归调用栈太深。
导致算法的时间复杂度退化到O(n^2).
*/
//快速排序的进一步优化 (二路快排) --> 将相同的元素均匀的分配到数组的两端
int partition5(int a[], int low ,int high){
int pivot = a[low];
int i = low+1;
int j = high;
while(true){
//a[i] >= pivot 结束循环
while( i <= high && a[i] < pivot) i++;
//a[j] <= pivot 结束循环
while( j >= low+1 && a[j] > pivot) j--;
if(i >= j){
break;
}
swap(a,i,j);
i++;
j--;
}
swap(a,j,low);
return j;
}
//快速排序的更进一步的优化(三路快排) --> 相同的元素不予处理
int QuickSort2(int a[],int low ,int high,int *max,int *count){
if(low < high){
(*count)++;
if((*max) < (*count)){
(*max) = (*count);
}
//让pivot的值尽量取中间元素,这样可以有效针对有序数组快排时间复杂度退化为O(n^2)的情况。(此种方式更高效,对于有序或者基本有序的数组,能使递归调用栈深度最低)
int mid = (low+high)/2;
//计算出三个数中的最大值
int max1=a[low] > a[mid] ? a[low]:a[mid];
max1=a[high]>max1?a[high]:max1;
//计算出三个数中的最小值
int min=a[low] < a[mid] ? a[low]:a[mid];
min=a[high] <min ?a[high]:min;
//中间值
int middle = a[mid]+a[low]+a[high]-max1-min;
if(middle != a[low]){
if(middle == a[mid]){
swap(a,low,mid);
}else{
swap(a,low,high);
}
}
//产生随机数的方式也可。
// srand((int)time(NULL));
// int index = random((high-low+1));
//将index位置的元素交换到开头
// swap(a,low,low+index);
//找基准元素
int pivot = a[low];
//lt是小于等于的分界线(始终指向小于的最后一个位置)
int lt = low;
//gt是大于等于的分界线, 也是遍历的终点 (始终指向大于的第一个位置)
int gt = high+1;
int i = low+1;
while(i<gt){
if(a[i] < pivot){
swap(a,lt+1,i);
lt++;
i++;
}else if (a[i] > pivot){
swap(a,gt-1,i);
gt--;
}else{
i++;
}
}
swap(a,low,lt);
QuickSort2(a,low,lt-1,max,count);
QuickSort2(a,gt,high,max,count);
(*count)--;
}
}
//a为要排序的数组 low为要排序数组第一个元素的下标, high为要排序数组最后一个元素的下标
void QuickSort(int a[],int low,int high,int *max ,int *count){
if(low < high){
(*count)++;
if((*max) < (*count)){
(*max) = (*count);
}
//这个pivotpos把当前数组分成了两个子表
int pivotpos = partition4(a,low,high);
//针对左子表找枢轴
QuickSort(a,low,pivotpos-1,max,count);
//针对右子表找枢轴
QuickSort(a,pivotpos+1,high,max,count);
(*count)--;
}
}
int main(int argc, char *argv[])
{
int a[] = {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20};
//int a[] = {49,49,56,49,49,49,49,49,49,49};
//新增两个变量,用来记录调用栈的最大深度
int count = 0;
int max = 0;
QuickSort2(a,0,19,&max,&count);
printf("调用栈的最大深度是%d\n",max);
for(int i = 0 ; i < 20; i++ ){
printf("%d ",a[i]);
}
return 0;
}
增加两个变量,记录递归调用栈的深度。
结果测试:
针对20个有序元素,采用最优的的快排代码, 递归调用栈最大深度是5.log20差不多也就是5.
针对大量重复元素的数组,采用最优的快排代码,递归调用栈最大深度为1。
结论:
采用最优的快排代码,无论是数组有序、基本有序、还是说数组中存在大量的重复元素。
或者说数组中兼具这两个特点,快排代码都能保证递归调用栈的深度维持在log2n的水平。
也就是说使用最优的快排代码对任意数组进行排序,时间复杂度都能保持在O(nlogn),空间复杂度保持在O(logn)的水平。