（三）几种排序算法的学习总结(快速排序)

快速排序：“二十世纪最伟大的算法”
核心思想：每次从数组中选择一个元素作为基点，之后把该元素移动到排好序时应该所处的位置，使得基点之前的元素都小于它、之后的元素都大于它。之后对小于它、大于它的子数组分别递归进行快速排序
将元素移动到合适位置的函数：Partition
通常使用第一个元素作为分界的标志点：索引——l，元素值——v
大于v与小于v的分界点索引：j
当前访问的元素索引：i，元素值：e
最终目的，使得：
arr[l+1…j]< v
arr[j+1….i-1]> v
分为两种情况：
1.e > v
2.e < v

再交换l与j位置的元素，使得基点在合适的位置上

//对arr[l...r]部分进行partition操作 //返回p，使得arr[l...p-1]<arr[p];arr[p+1...r]>arr[p] template<typename T>int __partition(T arr[],int l,int r){    //优化1：随机选取一个基数，而非最左端的元素    //swap(arr[rand()%(r-l+1)+l],arr[l]);     //基数、标准     T v=arr[l];    //i是当前考虑的位置     //arr[l+1...j]<v;arr[j+1...i)>v     int j=l;        //使得两个子数组初始都为空     for(int i=l+1;i<=r;i++){        if(arr[i]<v){            swap(arr[++j],arr[i]);            //j++;        }    }     swap(arr[l],arr[j]);    return j;} template<typename T>void __quickSort(T arr[],int l,int r){    //索引非法处理    if(l>=r)        return;    int p=__partition(arr,l,r);    __quickSort(arr,l,p-1);    __quickSort(arr,p+1,r);}template<typename T>void quickSort(T arr[],int n){    //优化1：设置随机种子     //srand(time(NULL));    __quickSort(arr,0,n-1);}

缺点1：对于近乎有序的数组排序效率低下，运行过程中形成的递归树平衡度较差，对于完全有序的数组，算法复杂度直接退化为O(n*n)。
优化1：随机选取排序的基准元素
缺点2：对于有大量重复键值的数组排序效率低下，同样可能造成算法复杂度退化为O(n^2)。
优化2：

//双路快速排序：template<typename T> int __partition2(T arr[],int l,int r){    swap(arr[rand()%(r-l+1)+l],arr[l]);         T v=arr[l];    //arr[l+1...i]<=v;arr[j...r]>=v     int i=l+1,j=r;    while(true){        while(i<=r&&arr[i]<v)i++;        while(j>=l+1&&arr[j]>v)j--;        if(i>j)break;        swap(arr[i],arr[j]);        //索引移动到下一个要考察的位置        i++;        j--;     }    //循环结束时三个索引：    //i: 从前向后看第一个大于等于v的位置     //j: 从后向前看第一个(数组中最后一个)小于等于v的元素位置    //v: 小于等于v一端     swap(arr[l],arr[j]);    return j; }

优化3：考虑到可能会有很多“等于v”的键值，还可以进一步优化出三路快速排序。增设一个存放“等于v”元素的子数组，直接省去这部分递归。
索引含义如下：
lt——指向“小于v”部分的最后一个元素，使得arr[l+1…lt] < v

gt——指向已经处理过的后面的第一个“大于v”部分的元素，使得arr[gt…r] > v

则arr[lt+1…i-1]==v
分情况讨论索引为i的元素：
1. e == v：该元素直接纳入“等于v”部分,i++
2. e < v ：将该位置元素和“等于v”部分的第一个元素交换，lt++
3. e > v ：将该位置元素直接与“gt-1”位置元素进行交换，gt–，i索引无需进行维护，依然指向了一个没有经过处理的元素

整个处理过程结束后，lt、gt分别指向了“小于v”部分和“大于v”部分的最后一个（第一个）元素，i与gt重合，此时交换l位置元素与lt位置元素即可

最后结果：
“小于v”部分：arr[l…lt-1] < v;
“等于v”部分：arr[lt…gt-1] ==v;
“大于v”部分：arr[gt…r] > v;

三路快速排序实现：

//三路快速排序处理：arr[l...r]//将arr[l...r]分为<v，==v,>v三个部分 //之后递归对<v,>v 两部分继续进行三路快速排序 template<typename T>void __quickSort3Ways(T arr[],int l,int r){    //递归结束判断    if(l>=r)        return;    //partition    swap(arr[rand()%(r-l+1)+l],arr[l]);    T v=arr[l];    //注意初始值的设定，必须满足三个子数组开始都为空     int lt=l; //arr[l+1...lt]<v     int gt=r+1; //arr[gt...r]>v     int i=l+1; //arr[lt+1...i)==v     while(i<gt){        if(arr[i]<v){            swap(arr[i],arr[lt+1]);            lt++;            i++;        }        else if(arr[i]>v){            swap(arr[i],arr[gt-1]);            gt--;            //i索引无需处理，依然指向了一个未经过处理的元素         }        else{//arr[i]==v             i++;        }    }    swap(arr[l],arr[lt]);    __quickSort3Ways(arr,l,lt-1);    __quickSort3Ways(arr,gt,r);}template<typename T>void quickSort3Ways(T arr[],int n){    srand(time(NULL));    __quickSort3Ways(arr,0,n-1);}

对于快速排序就介绍到这里了，更基础的选择、插入排序详见前两篇文章：http://blog.csdn.net/draper__qyt/article/details/77980407
http://blog.csdn.net/draper__qyt/article/details/77984775
注：本文的内容来自慕课网的课程《c++，java算法与数据结构》，主讲人为刘宇波老师~极力推荐！
这里附上课程链接：http://coding.imooc.com/class/71.html