include
include
using namespace std;
/*
时间复杂度:
递归时间复杂度公式:T(N) = aT(N/b) + f(N)
最优情况下时间复杂度:
快速排序最优的情况就是每一次取到的元素都刚好平分整个数组(很显然我上面的不是)
此时的时间复杂度公式则为:T(N) = 2T(N/2) + f(N);T[n/2]为平分后的子数组的时间复杂度,f[n] 为平分这个数组时所花的时间
下面来推算下,在最优的情况下快速排序时间复杂度的计算(用迭代法):
T[n] = 2T[n/2] + n ——第一次递归
令:n = n/2 = 2 { 2 T[n/4] + (n/2) } + n ----------------第二次递归
= 2^2 T[ n/ (2^2) ] + 2n
令:n = n/(2^2) = 2^2 { 2 T[n/ (2^3) ] + n/(2^2)} + 2n -------------第三次递归
= 2^3 T[ n/ (2^3) ] + 3n
..................................................................
令:n = n/( 2^(m-1) ) = 2^m T[1] + mn ----------------第m次递归(m次后结束)
当最后平分的不能再平分时,也就是说把公式一直往下跌倒,到最后得到T[1]时,
说明这个公式已经迭代完了(T[1]是常量了)。
得到:T[n/ (2^m) ] = T[1] ===>> n = 2^m ====>> m = logn;
T[n] = 2^m T[1] + mn ;其中m = logn;
T[n] = 2^(logn) T[1] + nlogn = n T[1] + nlogn = n + nlogn ;其中n为元素个数
又因为当n >= 2时:nlogn >= n (也就是logn > 1),所以取后面的 nlogn;
综上所述:快速排序最优的情况下时间复杂度为:O( nlogn )
最差情况下时间复杂度
最差的情况就是每一次取到的元素就是数组中最小/最大的,这种情况其实就是冒泡排序了(每一次都排好一个元素的顺序)
这种情况时间复杂度就好计算了,就是冒泡排序的时间复杂度:T[n] = n * (n-1) = n^2 + n;
综上所述:快速排序最差的情况下时间复杂度为:O( n^2 )
我就分析下就地快速排序的空间复杂度吧;
首先就地快速排序使用的空间是O(1)的,也就是个常数级;而真正消耗空间的就是递归调用了,因为每次递归就要保持一些数据;
最优的情况下空间复杂度为:O(logn) ;每一次都平分数组的情况
最差的情况下空间复杂度为:O( n ) ;退化为冒泡排序的情况
*/
//快排:不稳定,平均时间复杂度为O(NlogN),空间复杂度为O(1),就地排序!
void quick_sort(vector<int>&array,int low,int high) //左 右都是闭的
{
//终止条件,只剩一个数low==high
//执行条件:low<high
if (low<high)
{
//分割数组,设置pivot,找出pivot的index,并把比pivot大的放到index右边
int pivot = array[low];
int i = low,j = high;
while(i<j)
{
//右->左:找到第一个小于pivot的数
while(array[j]>=pivot && j>i) //擦,这里要&&上j>i防止j无限减小超出数组范围而溢出
j--;
if(i<j)
{
array[i] = array[j];
i++; //把i的坑填上,i的位置不再需要改变了
}
while(array[i]<=pivot && i<j) //同理!!
i++;
if(i<j)
{
array[j] = array[i];
j--; //把j的坑填上,j--
}
}
//跳出循环说明找到了i=j的index
array[i] = pivot; //把pivot放到正确的位置上
int pivotIndex = i;
//递归
quick_sort(array,low,pivotIndex-1);
quick_sort(array,pivotIndex+1,high);
}
}
/* 这是子函数模式
int partition(vector<int>&array,int low,int high)
{
//选择第一个数作为pivot基准,比pivot小的都移到左边,
//比pivot大的都移到右边,最后返回pivot所处的Index;
//
int pivot = array[low];
int i = low,j = high;
while(i<j)
{
//右->左:找到第一个小于pivot的数
while(array[j]>=pivot && j>i) //擦,这里要&&上j>i防止j无限减小超出数组范围而溢出
j--;
if(i<j)
{
array[i] = array[j];
i++; //把i的坑填上,i的位置不再需要改变了
}
while(array[i]<=pivot && i<j) //同理!!
i++;
if(i<j)
{
array[j] = array[i];
j--; //把j的坑填上,j--
}
}
//跳出循环说明找到了i=j的index
array[i] = pivot; //把pivot放到正确的位置上
return i;
}
void quick_sort(vector<int>&array,int low,int high) //左 右都是闭的
{
//终止条件,只剩一个数low==high
//执行条件:low<high
if (low<high)
{
int pivotIndex = partition(array,low,high); //函数里对array向量的元素进行了移动,需要传引用保存
quick_sort(array,low,pivotIndex-1);
quick_sort(array,pivotIndex+1,high);
}
}
*/
int main(int argc, char** argv) {
vector<int> array;
for(int i=0;i<10;i++)
{
array.push_back(5-i);
cout<<array[i]<<',';
}
cout<<endl;
quick_sort(array,0,9);
for(int i=0;i<10;i++)
cout<<array[i]<<',';
return 0;
}