剑指offer#快速排序

解法一：

#include<iostream>
using namespace std;
void Quick_Sort(int arr[],int start,int end,int length){
    int i = start, j = end;
    int temp = arr[i];
    if(i<j){
        while(i<j){
            while(i<j && arr[j]>temp) j--;
            if(i<j){
                arr[i] = arr[j];
                i++;
            }
            while(i<j && arr[i]<temp) i++;
            if(i<j){
                arr[j] = arr[i];
                j--;
            }
        }
        arr[i] = temp;
        Quick_Sort(arr,start,i-1,length);
        Quick_Sort(arr,i+1,end,length);
    }
}

解法二：

分析:双指针法，一个快指针遍历所有元素，一个慢指针small一直保存在大于temp值的元素的前一个位置，当查找到比temp小的元素我们就用其跟small的下一个元素进行交换，最后是temp交换到交界处!

void Quick_Sort2(int arr[],int start,int end,int length){
    int i = start,j = end;
    int temp = arr[end];
    int small = start-1;
    if(i<j){
        while(i<j){
            if(arr[i]<temp){
                ++small;
                if(small!=i){
                    int t = arr[small];
                    arr[small] = arr[i];
                    arr[i] = t;
                }
            }
            i++;
        }
        //交界处交换值
        ++small;
        int t = arr[small];
        arr[small] = arr[end];
        arr[end] = t;
        Quick_Sort2(arr,start,small-1,length);
        Quick_Sort2(arr,small+1,end,length);
    }

}

复杂度分析：

1. 时间复杂度：
   快速排序采用的是递归的方法，因此其运行过程实际上是一棵二叉树。
   1. 最优情况下
      每次划分都很均匀，因此n个关键字，递归树的深度是log2n+1，假设所需时间是T(n)，一次 比较需要遍历数组，因此做n次比较，划分一次后，分成两半，各自所需时间是T(n/2)，因此有`

T(n) <= 2T(n/2) + n,T(1) = 0
T(n) <= 2 ( 2*T(n/4) + n/2) + n = 4T(n/4) + 2n
...
T(n) <= nT(1) + (log2n) * n = O(nlogn)

因此最优情况下是O(nlogn).
2.最坏情况下，就是有序情况下，每次划分只能找到一个比上次少一个元素的子序列，然后画递归树就是一棵斜的树，需要n-1次调用，并且第i次划分需要经过n-i次关键字的比较才能找到第i个记录，即枢轴所在的位置，因此比较次数是

因此时间复杂度是O(n2)
3.平均情况下，设枢轴的关键字应该在第k的位置（1<=k<=n），则

得用数学归纳法证明可得数量级是O(nlogn)。
2.空间复杂度：
最好情况下递归树的高度是O(logn)
最坏情况下是O(n)
平均情况下是O(logn)