vs2013 std::sort 分析

由于之前在debug模式下发现stl的sort简直慢到不能忍，所以自己写了一个sgi的sort，后来发现在release模式下，vs自带的sort快的不行，就研究了下。

这里有些和sgi-stl相通的东西就简略带过了，详细内容可以看我之前的stl源码的笔记：

sgi-sort_link

首先来看下大概的过程：

1.没有调用到一定深度时，就进行划分并进行递归调用。
2.如果超过了一定深度时，这个区间改为调用堆排序。(这一部待商榷)
3.对剩下的小于32长度的区间进行插入排序。

接下来是详细分析：

1：当我们调用sort(frist,last);时，程序就来到下面的代码，帮忙添加一个参数：less<>()默认用<来比较。

template<class _RanIt> inline
void sort(_RanIt _First, _RanIt _Last)
{   // order [_First, _Last), using operator<
_STD sort(_First, _Last, less<>());
}

2：接着来到，这时会调用真正的sort，也就是_Sort

template<class _RanIt,
class _Pr> inline
void sort(_RanIt _First, _RanIt _Last, _Pr _Pred)
{   // order [_First, _Last), using _Pred
_DEBUG_RANGE(_First, _Last);
_DEBUG_POINTER(_Pred);
_Sort(_Unchecked(_First), _Unchecked(_Last), _Last - _First, _Pred);
}

3：然后进入真正的sort：这里进行说明

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;
//_Count是计算出来的传入的元素个数，貌似为了安全，还要传入一个元素个数的参数
//也就是_Ideal
for (; _ISORT_MAX < (_Count = _Last - _First) && 0 < _Ideal; )
{   // divide and conquer by quicksort
// 这个循环的原因是为了继续划分
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 second half
_Sort(_First, _Mid.first, _Ideal, _Pred);
_First = _Mid.second;
}
else
{   // loop on first half
_Sort(_Mid.second, _Last, _Ideal, _Pred);
_Last = _Mid.first;
}
}
//划分到区间小于_ISORT_MAX

//深度太深，改为堆排序。为什么我感觉这是永远不会执行到的因为_ISORT_MAX <_Count
//不是上一个循环的结束判断条件么
//而且在release模式下，我设断点都会直接跳过，并不执行if的判断
//所以目测是不会执行的
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)//到了底层，就调用插入排序了，奇怪的是为什么不学sgi的插入排序，可以
//节省很多次的判断。
_Insertion_sort(_First, _Last, _Pred);  // small
}

4：下面看看重头戏：

template<class _RanIt,
class _Pr> inline
pair<_RanIt, _RanIt>
_Unguarded_partition(_RanIt _First, _RanIt _Last, _Pr _Pred)
{   // partition [_First, _Last), using _Pred

//找到最中间的元素。
_RanIt _Mid = _First + (_Last - _First) / 2;

//_Median这个函数的作用是把头中尾这三个数进行排序，还会把头中尾附近三个左右的元素进行排序
//具体不必关心，这里只要知道头中尾三个元素是排好序的。而且_Mid就是关键划分元素
_Median(_First, _Mid, _Last - 1, _Pred);

//_Pfirst 是左半部分的last，_Plast 是右半部分的first值
//这里虽然看起来first和last颠倒了，其实这两个值的意思是[_Pfirst, _Plast)区间的元素值
//全部是_Mid的值("_Mid指向的值"下面简称：mid)；
_RanIt _Pfirst = _Mid;
_RanIt _Plast = _Pfirst + 1;

//有重复的值就左移或右移动来扩大区间最后达到的效果是这样的[_Pfirst..一堆mid.._Plast)
//注意_Pfirst和_Plast-1指向的值也是mid
while (_First < _Pfirst
&& !_DEBUG_LT_PRED(_Pred, *(_Pfirst - 1), *_Pfirst)
&& !_Pred(*_Pfirst, *(_Pfirst - 1)))
--_Pfirst;
while (_Plast < _Last
&& !_DEBUG_LT_PRED(_Pred, *_Plast, *_Pfirst)
&& !_Pred(*_Pfirst, *_Plast))
++_Plast;

//这两个值分别是未划分的左边部分的尾部：_Glast 以及右半部分的头部：_Gfirst
_RanIt _Gfirst = _Plast;
_RanIt _Glast = _Pfirst;

//这时完整的区间是这样的[_First....[_Pfirst(同时也是_Glast)..._Plast)
//...._Last)！！注意这里是开区间哈   _Plast也是_Gfirst，为了好看，就写在这了
for (; ; )
{   // 划分开始了。。。
for (; _Gfirst < _Last; ++_Gfirst)//先进行边界判断
{
//从右半边开始，只要_Gfirst指向的值(下面指向的值都去掉“指向的值”这四个字来简称)
//比_Pfirst(也就是mid)大就一直++
//直到找到比_Pfirst小的值这样就可以和_Pfirst-1的元素进行交换了
if (_DEBUG_LT_PRED(_Pred, *_Pfirst, *_Gfirst))
;
else if (_Pred(*_Gfirst, *_Pfirst))//找到
break;

//一个小插曲：如果找到和mid一样大的值就把这个值换到_Plast++的位置来保持
//[_Pfirst, _Plast)区间全是mid;
else if (_Plast++ != _Gfirst)//如果两个位置相同就不用换了
_STD iter_swap(_Plast - 1, _Gfirst);
}

//同上面，相应的左区间的操作，最后找到大于mid的位置。
//只要注意stl右边都是开区间的，_Glast-1才是前面区间的最后一个值
for (; _First < _Glast; --_Glast)
{
if (_DEBUG_LT_PRED(_Pred, *(_Glast - 1), *_Pfirst))
;
else if (_Pred(*_Pfirst, *(_Glast - 1)))
break;
else if (--_Pfirst != _Glast - 1)
_STD iter_swap(_Pfirst, _Glast - 1);
}

//达到边界就返回一个pair指向mid区间
//这里的判断是这样的:
//1:_Glast 是左边未划分区间的最后一个元素的后一个位置所以_First之前
//未划分_First开始，已经划分。
//2:_Gfirst 代表右边未划分的第一个元素，而_Last是我们需要划分的区间的最后一个
//元素的后一个位置，所以如果下面条件成立，[_First ,_Last)划分完成
if (_Glast == _First && _Gfirst == _Last)
return (pair<_RanIt, _RanIt>(_Pfirst, _Plast));

//左边全部划分完了，看起来像这样[_First(_Glast,)..._Pfirst..............)
//这时如果要交换左右两边的元素就需要特殊处理了
if (_Glast == _First)
{   // no room at bottom, rotate pivot upward

//情况1：如果_Plast ==_Gfirst说明_Gfirst就是mid区间的last位置
//这时只需要交换_Pfist和_Gfirst就可以把mid区间右移一格
if (_Plast != _Gfirst)
_STD iter_swap(_Pfirst, _Plast);
//情况2：先把一个mid换到最后面，这时_Pfirst指向一个大于mid的值，_Gfirst是指向小于mid的值的。

//++_Plast， 因为中间全是mid的区间要整个后移一格
++_Plast;

//情况1：交换_Pfist和_Gfirst相当于把第一个mid值和右边大于mid的值交换
//情况2：交换_Pfirst，_Gfirst，刚好把小的换到左边，大的换到右边
_STD iter_swap(_Pfirst++, _Gfirst++);
}
else if (_Gfirst == _Last)
{   // no room at top, rotate pivot downward
if (--_Glast != --_Pfirst)
_STD iter_swap(_Glast, _Pfirst);
_STD iter_swap(_Pfirst, --_Plast);
}
else

//交换左右区间元素。
_STD iter_swap(_Gfirst++, --_Glast);
}

//这个其实就是双基准快排的实现，相对于普通快排最后得到的结果就是把_Mid元素都集中在
//一起了.
}

到此完结，能看到这相信你肯定已经懂了哈，有不对的地方希望大神指出，谢谢！