STL sort

 

template<class _RanIt> inline
    void sort(_RanIt _First, _RanIt _Last)
{    // order [_First, _Last), using operator<
    _DEBUG_RANGE(_First, _Last);
    _Sort(_CHECKED_BASE(_First), _CHECKED_BASE(_Last), _Last - _First);
}

template<class _RanIt,
    class _Diff,
    class _Pr> inline
    void _Sort(_RanIt _First, _RanIt _Last, _Diff _Ideal, _Pr _Pred)
    {
    // order [_First, _Last), using _Pred
    _Diff _Count;
    for (; _ISORT_MAX < (_Count = _Last - _First) && 0 < _Ideal; )
    {
        // divide and conquer by quicksort

        // First, we get the middle position, divide the set to two part
        pair<_RanIt, _RanIt> _Mid =
            _Unguarded_partition(_First, _Last, _Pred);


        _Ideal /= 2, _Ideal += _Ideal / 2;    // allow 1.5 log2(N) divisions

        if (_Mid.first - _First < _Last - _Mid.second)    // loop on larger half
            _Sort(_First, _Mid.first, _Ideal, _Pred), _First = _Mid.second;
        else
            _Sort(_Mid.second, _Last, _Ideal, _Pred), _Last = _Mid.first;
    }

    if (_ISORT_MAX < _Count)
    {
        // heap sort if too many divisions
        std::make_heap(_First, _Last, _Pred);
        std::sort_heap(_First, _Last, _Pred);
    }
    else if (1 < _Count)
        _Insertion_sort(_First, _Last, _Pred);    // small, insertion sort
    }

其中

// COMMON SORT PARAMETERS
const int _ISORT_MAX = 32;    // maximum size for insertion sort

 

1. _ISORT_MAX用来控制能够conquer的集合的大小，如果集合已经足够小了，比如这里集合中元素的个数小于32个，则可以使用Insertion_Sort来进行排序操作了；

2. _Ideal用来控制(Divide-and-Conquer)递归的层次，

相当 (N * 1.5^_Ideal) >> (_Ideal) 次就达到了0，即2^_Ideal == N*1.5^_Ideal,

即_Ideal = log_4/3N, 但是实际上由于在“除2”操作过程中的低位损耗，_Ideal的值会比公式计算出来的偏小，不过原comment给出的1.5 log2(N)是不准确的，以下做了一些对比

int x = 1024;
    int y = 0;
    while (x > 0)
    {
        x /= 2, x += x / 2;
        printf("0x%08X\n", x);
        y++;
    }

N	1.5 log2(N)	log4/3N	程序计算出的值y
1024	15	24	21

 

言归正传，当_Ideal的层次太深的时候，for循环结束

3. 如果不是因为分块已经足够小了而结束的，就调用Heap_Sort进行堆排序

4. 如果分块已经都足够小了，就进行Insertion_Sort排序