STL sort源码剖析

时间  2019-11-26
标签 stl sort 源码 剖析 繁體版
原文   原文链接

转载自：http://www.cnblogs.com/imAkaka/articles/2407877.html

STL的sort()算法，数据量大时采用Quick Sort，分段递归排序，一旦分段后的数据量小于某个门槛，为避免Quick Sort的递归调用带来过大的额外负荷，就改用Insertion Sort。若是递归层次过深，还会改用Heap Sort。本文先分别介绍这个三个Sort，再整合分析STL sort算法(以上三种算法的综合) -- Introspective Sorting(内省式排序)。html

1、Insertion Sort

Insertion Sort是《算法导论》一开始就讨论的算法。它的基本原理是：将初始序列的第一个元素做为一个有序序列，而后将剩下的N-1个元素按关键字大小依次插入序列，并一直保持有序。这个算法的复杂度为O(N^2)，最好状况下时间复杂度为O(N)。在数据量不多时，尤为仍是在序列“几近排序但还没有完成”时，有着很不错的效果。算法

 

    // 默认以渐增方式排序
    template <class RandomAccessIterator>
    void __insertion_sort(RandomAccessIterator first,
        RandomAccessIterator last)
    {
        if (first == last) return;
                // --- insertion sort 外循环 ---
        for (RandomAccessIterator i = first + 1; i != last; ++i)
            __linear_insert(first, i, value_type(first));
        // 以上，[first,i) 造成一个子区间
    }

    template <class RandomAccessIterator, class T>
    inline void __linear_insert(RandomAccessIterator first,
        RandomAccessIterator last, T*)
    {
        T value = *last;      // 记录尾元素
        if (value < *first){      // 尾比头还小 (注意，头端必为最小元素)
            copy_backward(first, last, last + 1);    // 将整个区间向右移一个位置
            *first = value;      // 令头元素等于原先的尾元素值
        }
        else    // 尾不小于头
            __unguarded_linear_insert(last, value);
    }

    template <class RandomAccessIterator, class T>
    void __unguarded_linear_insert(RandomAccessIterator last, T value)
    {
        RandomAccessIterator next = last;
        --next;

        // --- insertion sort 内循环 ---
        // 注意，一旦再也不出现逆转对(inversion),循环就能够结束了
        while (value < *next){    // 逆转对(inversion)存在
            *last = *next;        // 调整
            last = next;        // 调整迭代器    
            --next;            // 左移一个位置
        }
        *last = value;            // value 的正确落脚处
    }

 

上述函数之因此命名为unguarded_x是由于，通常的Insertion Sort在内循环本来须要作两次判断，判断是否相邻两元素是”逆转对“，同时也判断循环的行进是否超过边界。但因为上述所示的源代码会致使最小值必然在内循环子区间的边缘，因此两个判断可合为一个判断，因此称为unguarded_。省下一个判断操做，在大数据量的状况下，影响仍是可观的。数组

2、Quick Sort

Quick Sort是目前已知最快的排序法，平均复杂度为O(NlogN)，但是最坏状况下将达O(N^2)。dom

Quick Sort算法能够叙述以下。假设S表明将被处理的序列：函数

一、若是S的元素个数为0或1，结束。oop

二、取S中的任何一个元素，当作枢轴(pivot) v。测试

三、将S分割为L、R两段，使L内的每个元素都小于或等于v，R内的每个元素都大于或等于v。大数据

四、对L、R递归执行Quick Sort。ui

Median-of-Three（三点中值）设计

由于任何元素均可以当作枢轴(pivot)，为了不元素输入时不够随机带来的恶化效应，最理想最妥当的方式就是取整个序列的投、尾、中央三个元素的中值(median)做为枢轴。这种作法称为median-of-three partitioning。

 

 

    // 返回 a，b，c之居中者
    template <class T>
    inline const T& __median(const T& a, const T& b, const T& c)
    {
        if (a < b)
            if (b < c)        // a < b < c
                return b;
            else if (a < c)    // a < b, b >= c, a < c  -->     a < b <= c
                return c;
            else            // a < b, b >= c, a >= c    -->     c <= a < b
                return a;
        else if (a < c)        // c > a >= b
            return a;
        else if (b < c)        // a >= b, a >= c, b < c    -->   b < c <= a
            return c;
        else                // a >= b, a >= c, b >= c    -->      c<= b <= a
            return b;        
    }

 

Partitioning（分割）

分割方法有不少，如下叙述既简单又有良好成效的作法。令first向尾移动，last向头移动。当*first大于或等于pivot时停下来，当*last小于或等于pivot时也停下来，而后检验两个迭代器是否交错。未交错则元素互相，而后各自调整一个位置，再继续相同行为。若交错，则以此时first为轴将序列分为左右两半，左边值都小于或等于pivot，右边都大于等于pivot

 

 

    template <class RandomAccessIterator, class T>
    RandomAccessIterator __unguarded_partition(
                                    RandomAccessIterator first,
                                    RandomAccessIterator last,
                                    T pivot)
    {
        while(true){
            while (*first < pivot) ++first;    // first 找到 >= pivot的元素就停
            --last;

            while (pivot < *last) --last;    // last 找到 <=pivot

            if (!(first < last)) return first;    // 交错，结束循环    
        //    else
            iter_swap(first,last);                // 大小值交换
            ++first;                            // 调整
        }
    }

 

3、Heap Sort

STL中有一个partial_sort()算法。

 

 

    // paitial_sort的任务是找出middle - first个最小元素。
    template <class RandomAccessIterator>
    inline void partial_sort(RandomAccessIterator first,
                             RandomAccessIterator middle,
                             RandomAccessIterator last)
    {
        __partial_sort(first, middle, last, value_type(first));
    }
    template <class RandomAccessIterator,class T>
    inline void __partial_sort(RandomAccessIterator first,
                            RandomAccessIterator middle,
                            RandomAccessIterator last, T*)
    {
        make_heap(first, middle); // 默认是max-heap，即root是最大的
        for (RandomAccessIterator i = middle; i < last; ++i)
            if (*i < *first)
                __pop_heap(first, middle, i, T(*i), distance_type(first));
        sort_heap(first,middle);
    }

 

partial_sort的任务是找出middle-first个最小元素，所以，首先界定出区间[first,middle)，并利用make_heap()将它组织成一个max-heap，而后就能够讲[middle,last)中的每个元素拿来与max-heap的最大值比较(max-heap的最大值就在第一个元素)；若是小于该最大值，就互换位置并从新保持max-heap的状态。如此一来，当咱们走遍整个[middle,last)时，较大的元素都已经被抽离出[first,middle)，这时候再以sort_heap()将[first,middle)作一次排序。

因为篇幅有限，本文再也不阐述堆的具体实现，建议海量Google。

4、IntroSort

不当的枢轴选择，致使不当的分割，致使Quick Sort恶化为O(N^2)。David R. Musser于1996年提出一种混合式排序算法，Introspective Sorting。其行为在大部分状况下几乎与 median-of-3 Quick Sort彻底相同。可是当分割行为(partitioning)有恶化为二次行为倾向时，能自我侦测，转而改用Heap Sort，使效率维持在O(NlogN)，又比一开始就使用Heap Sort来得好。大部分STL的sort内部其实就是用的IntroSort。

    template <class RandomAccessIterator>
    inline void sort(RandomAccessIterator first,
                    RandomAccessIterator last)
    {
        if (first != last){
            __introsort_loop(first, last, value_type(first), __lg(last-first)*2);
            __final_insertion_sort(first,last);
        }
                                                                                                       
    }
    // __lg()用来控制分割恶化的状况
    // 找出2^k <= n 的最大值,例：n=7得k=2; n=20得k=4
    template<class Size>
    inline Size __lg(Size n)
    {
        Size k;
        for (k = 0; n > 1; n >>= 1)
            ++k;
        return k;
    }

        // 当元素个数为40时,__introsort_loop的最后一个参数
        // 即__lg(last-first)*2是5*2,意思是最多容许分割10层。

    const int  __stl_threshold = 16;

    template <class RandomAccessIterator, class T, class Size>
    void __introsort_loop(RandomAccessIterator first,
                    RandomAccessIterator last, T*,
                    Size depth_limit)
    {
        while (last - first > __stl_threshold){        // > 16
            if (depth_limit == 0){                    // 至此，分割恶化
                partial_sort(first, last, last);    // 改用 heapsort
                return;
            }

            --depth_limit;
            // 如下是 median-of-3 partition，选择一个够好的枢轴并决定分割点
            // 分割点将落在迭代器cut身上
            RandomAccessIterator cut = __unguarded_partition
                (first, last, T(__median(*first,
                                         *(first + (last - first)/2),
                                        *(last - 1))));

            // 对右半段递归进行sort
            __introsort_loop(cut,last,value_type(first), depth_limit);

            last = cut;
            // 如今回到while循环中，准备对左半段递归进行sort
            // 这种写法可读性较差，效率也并无比较好
        }
    }

 

函数一开始就判断序列大小，经过个数检验以后，再检测分割层次，若分割层次超过指定值，就改用partial_sort()，即Heap sort。都经过了这些校验以后，便进入与Quick Sort彻底相同的程序。

当__introsort_loop()结束，[first,last)内有多个“元素个数少于或等于”16的子序列，每一个序列有至关程序的排序，但还没有彻底排序（由于元素个数一旦小于 __stl_threshold，就被停止了）。回到母函数，再进入__final_insertion_sort()：

    template <class RandomAccessIterator>
    void __final_insertion_sort(RandomAccessIterator first,
        RandomAccessIterator last)
    {
        if (last - first > __stl_threshold){  
            // > 16
            // 1、[first,first+16)进行插入排序
            // 2、调用__unguarded_insertion_sort，实质是直接进入插入排序内循环，
            //       *参见Insertion sort 源码
            __insertion_sort(first,first + __stl_threshold);
            __unguarded_insertion_sort(first + __stl_threshold, last);
        }
        else
            __insertion_sort(first, last);
    }

    template <class RandomAccessIterator>
    inline void __unguarded_insertion_sort(RandomAccessIterator first,
        RandomAccessIterator last)
    {
__unguarded_insertion_sort_aux(first, last, value_type(first));
    }

    template <class RandomAccessIterator, class T>

    void __unguarded_insertion_sort_aux(RandomAccessIterator first,
        RandomAccessIterator last,
        T*)
    {
        for (RandomAccessIterator i = first; i != last; ++i)
            __unguarded_linear_insert(i, T(*i));
    }

 

必需要看清楚的是，__final_insertion_sort()以前，通过__introsort_loop()的整个序列能够当作是一个个元素个数小于或等于16的子序列(注意子序列长度是不等的)，且这些子序列不但内部有至关程度排序，且更重要的是以子序列与子序列之间也是“递增”的，意思是前一个子序列中的元素都是小于后一个子序列中的元素的，因此这个时候运用insertion_sort()，效率但是至关高的。

/---------------------------------------华丽的分割线--------------------------------------/

关于IntroSort的测试。

细看__introsort_loop()，是否是以为他的快排的写法很怪，为何不能直接这样写呢？

if (last - first > __stl_threshold){		// > 16
...
...
__introsort_loop(cut,last,value_type(first), depth_limit);
__introsort_loop(first,cut,value_type(first), depth_limit);

因而，我作了一次测试，结果以下图：

测试结果发现，若是不像STL中那么写，其实在数组还比较小时，还快那么一丁点，

而且即便数组变大，在一百万条记录时也只快0.3秒，唔。。也许STL更注重于大型数据吧，

不过像他那么写，实在是牺牲了代码的可读性。

为何是Insertion Sort，而不是Bubble Sort。

选择排序(Selection sort)，插入排序(Insertion Sort)，冒泡排序(Bubble Sort)。这三个排序是初学者必须知道的三个基本排序方式，且他们速度都不快 -- O(N^2)。选择排序就不说了，最好状况复杂度也得O(N^2)，且仍是个不稳定的排序算法，直接淘汰。

可冒泡排序和插入排序相比较呢？

首先，他们都是稳定的排序算法，且最好状况下都是O(N^2)。那么我就来对他们的比较次数和移动元素次数作一次对比（最好状况下），以下：

插入排序：比较次数N-1，移动元素次数2N-1。

冒泡排序：比较次数N-1，无需移动元素。(注：我所说的冒泡排序在最基本的冒泡排序基础上还利用了一下旗帜的方式，即寻访完序列未发生数据交换时则表示排序已完成，无需再进行以后的比较与交换动做）

那么，这样看来冒泡岂不是是更快，我能够把上述的__final_insertion_sort()函数改为一个__final_bubble_sort()，把每一个子序列分别进行冒泡排序，岂不是更好？

事实上，具体实现时，我才发现这个想法错了，由于写这么一个__final_bubble_sort()，我没有办法肯定每一个子序列的大小，可我仍是不甘心呐，就把bubble_sort()插在__introsort_loop()最后，这样确实是每一个子序列都用bubble_sort()又排序了一次，但是测试结果太惨了，由此能够看书Bubble Sort在“几近排序但还没有完成”的状况下是没多少改进做用的。

为何不直接用Heap Sort

堆排序将全部的数据建成一个堆，最大的数据在堆顶，它不须要递归或者多维的暂存数组。算法最优最差都是O(NlogN)，不像快排，若是你人品够差还能恶化到O(N^2)。当数据量很是大时（百万数据），由于快排是使用递归设计算法的，还可能发出堆栈溢出错误呢。

那么为何不直接用Heap Sort？或者说给一个最低元素阈值（__stl_threshold)时也给一个最大元素阈值（100W），即当元素数目超过这个值时，直接用Heap Sort，避免堆栈溢出呢？

对于第一个问题，我测试了一下，发现直接用Heap Sort，有时尚未Quick Sort快呢，查阅《算法导论》发现，原来虽然Quick和Heap的时间复杂性是同样的，但堆排序的常熟因子仍是大些的，而且堆排序过程当中重组堆其实也不是个省时的事。

VS2010版STL中的sort竟比我本身写的快这么多？

首先，上文实现的这个Introsort是参照SGI STL写的，因而，我斗胆在VS2010中拿他与std:sort比了比快慢。因而就随机产生两个百万数据的vector用来测试。结果发现，VS中sort的速度竟是个人10倍以上的效率。顿时对微软萌生敬意，但是当我仔细翻看源码时.....
原来，microsoft的sort并无比sgi的sort快。只是在排序vector时，microsoft把vector的本质数据“萃取”出来了。
即，取消了vector在++时的边界检查语句，把vector::iterator当指针通常使用。因此才在对vector排序时会比我本身写的introsort算法快那么多呢。

Over

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程