STL源码解析 - nth_element

STL源码解析 - nth_element

nth_element 模板函数具有两个版本

 

 template<class _RanIt>
 void nth_element(_RanIt _First, _RanIt _Nth, _RanIt _Last);

 template<class _RanIt, class _Pr>
 void nth_element(_RanIt _First, _RanIt _Nth, _RanIt _Last, _Pr _Pred);

其功能是对区间 [_First, _Last) 的元素进行重排，其中位于位置 _Nth 的元素与整个区间排序后位于位置 _Nth 的元素相同，并且满足在位置 _Nth 之前的所有元素都“不大于”它和位置 _Nth 之后的所有元素都“不小于”它，而且并不保证 _Nth 的前后两个区间的所有元素保持有序。

第一个版本，比较操作默认使用小于操作符(operator<)；第二个版本，使用自定义谓词 "_Pred" 定义“小于”操作(Less Than)。

算法的空间复杂度为O(1)。

由于算法主要分两部分实现，第一部分是进行二分法弱分区，第二部分是对包含 _Nth 的位置的区间进行插入排序（STL的阈值为32）。当元素较多时平均时间复杂度为O(N)，元素较少时最坏情况下时间复杂度为O(N^2)。

下面针对第一个版本的算法源代码进行注释说明，版本为 Microsoft Visual Studio 2008 SP1 安装包中的 algorithm 文件

 

 template<class _RanIt> inline
 void nth_element(_RanIt _First, _RanIt _Nth, _RanIt _Last)
 {   // order Nth element, using operator<
     _Nth_element(_CHECKED_BASE(_First), _CHECKED_BASE(_Nth), _CHECKED_BASE(_Last)); // 转调用内部实现函数
 }

_Nth_element 函数实现，其中 _ISORT_MAX 值为 32。

 

 template<class _RanIt> inline
     void _Nth_element(_RanIt _First, _RanIt _Nth, _RanIt _Last)
     {   // order Nth element, using operator<
     _DEBUG_RANGE(_First, _Last);
     for (; _ISORT_MAX < _Last - _First; )
         {   // divide and conquer, ordering partition containing Nth
         pair<_RanIt, _RanIt> _Mid =
             std::_Unguarded_partition(_First, _Last);

         if (_Mid.second <= _Nth)
             _First = _Mid.second;
         else if (_Mid.first <= _Nth)
             return; // Nth inside fat pivot, done
         else
             _Last = _Mid.first;
         }

     // 插入排序
     std::_Insertion_sort(_First, _Last);    // sort any remainder
     }

 

_Unguarded_partition 函数实现

 

 template<class _RanIt> inline
     pair<_RanIt, _RanIt> _Unguarded_partition(_RanIt _First, _RanIt _Last)
     {   // partition [_First, _Last), using operator<
     _RanIt _Mid = _First + (_Last - _First) / 2;    // sort median to _Mid
     std::_Median(_First, _Mid, _Last - 1);  // 端点排序
     _RanIt _Pfirst = _Mid;
     _RanIt _Plast = _Pfirst + 1;    // 起始返回区间为 [_Mid, _Mid + 1)

     // 以下两个循环将不处理与 *_Mid 值相同的元素
     while (_First < _Pfirst
         && !_DEBUG_LT(*(_Pfirst - 1), *_Pfirst)
         && !(*_Pfirst < *(_Pfirst - 1)))
         --_Pfirst;
     while (_Plast < _Last
         && !_DEBUG_LT(*_Plast, *_Pfirst)
         && !(*_Pfirst < *_Plast))
         ++_Plast;

     // 当前返回区间为 [_Pfirst, _Plast)，且区间内值均相等
     _RanIt _Gfirst = _Plast;
     _RanIt _Glast = _Pfirst;

     for (; ; )
         {   // partition
         // 后半区间
         for (; _Gfirst < _Last; ++_Gfirst)
             if (_DEBUG_LT(*_Pfirst, *_Gfirst))  // 大于首值，迭代器后移
                 ;
             else if (*_Gfirst < *_Pfirst)        // 小于首值，退出循环
                 break;
             else
                 std::iter_swap(_Plast++, _Gfirst);  // 与首值相等，末迭代器后移，更新末值
         // 前半区间
         for (; _First < _Glast; --_Glast)
             if (_DEBUG_LT(*(_Glast - 1), *_Pfirst)) // 小于首值，迭代器前移
                 ;
             else if (*_Pfirst < *(_Glast - 1))       // 大于首值，退出循环
                 break;
             else
                 std::iter_swap(--_Pfirst, _Glast - 1);  // 与首值相等，首迭代器前移，更新首值

         // 整体区间已经处理结束
         if (_Glast == _First && _Gfirst == _Last)
             return (pair<_RanIt, _RanIt>(_Pfirst, _Plast));

         // 到达起点
         if (_Glast == _First)
             {   // no room at bottom, rotate pivot upward
             if (_Plast != _Gfirst)
                 std::iter_swap(_Pfirst, _Plast);    // if 成立，_Pfirst 暂存大值
             ++_Plast;                               // 末迭代器后移
             std::iter_swap(_Pfirst++, _Gfirst++);   // if 成立时，小值将存于返回区间首，最终结果是，返回区间整体右移
             }
         else if (_Gfirst == _Last)  // 到达终点
             {   // no room at top, rotate pivot downward
             if (--_Glast != --_Pfirst)
                 std::iter_swap(_Glast, _Pfirst);    // if 成立，_Pfirst 暂存大值
             std::iter_swap(_Pfirst, --_Plast);  // if 成立时，大值将存于返回区间尾，最终结果是，返回区间整体左移
             }
         else
             std::iter_swap(_Gfirst++, --_Glast);    // 交换后，*_Glast < *_Pfirst < *(_Gfirst - 1)
         }
     }

 

_Median 和 _Med3 两个函数，其作用是对区间内的特定几个数进行排序

 

 template<class _RanIt> inline
     void _Med3(_RanIt _First, _RanIt _Mid, _RanIt _Last)
     {   // sort median of three elements to middle - 3 点排序
     if (_DEBUG_LT(*_Mid, *_First))
         std::iter_swap(_Mid, _First);
     if (_DEBUG_LT(*_Last, *_Mid))
         std::iter_swap(_Last, _Mid);
     if (_DEBUG_LT(*_Mid, *_First))
         std::iter_swap(_Mid, _First);
     }

 template<class _RanIt> inline
     void _Median(_RanIt _First, _RanIt _Mid, _RanIt _Last)
     {   // sort median element to middle
     if (40 < _Last - _First)
         {   // median of nine - 9 端点排序
         size_t _Step = (_Last - _First + 1) / 8;
         std::_Med3(_First, _First + _Step, _First + 2 * _Step);
         std::_Med3(_Mid - _Step, _Mid, _Mid + _Step);
         std::_Med3(_Last - 2 * _Step, _Last - _Step, _Last);
         std::_Med3(_First + _Step, _Mid, _Last - _Step);
         }
     else
         std::_Med3(_First, _Mid, _Last);
     }

 

对于第二个版本，算法思想相同，只是要做比较操作时，将用 _Pred 替换 operator< 操作符，同时也看到算法的核心主要在于 _Unguarded_partition 这个函数。

_Insertion_sort 函数，插入排序

 

 template<class _BidIt> inline
     void _Insertion_sort(_BidIt _First, _BidIt _Last)
     {   // insertion sort [_First, _Last), using operator<
     std::_Insertion_sort1(_First, _Last, _Val_type(_First)); // 转调用 _Insertion_sort1
     }

_Insertion_sort1 函数

 

 template<class _BidIt,
     class _Ty> inline
     void _Insertion_sort1(_BidIt _First, _BidIt _Last, _Ty *)
     {   // insertion sort [_First, _Last), using operator<
     if (_First != _Last)
         for (_BidIt _Next = _First; ++_Next != _Last; )
             {   // order next element
             _BidIt _Next1 = _Next;
             _Ty _Val = *_Next;

             // 小于首值时，整体后移，有可能使用 memmove，因而存在优化
             if (_DEBUG_LT(_Val, *_First))
                 {   // found new earliest element, move to front - [_First, _Next) => [..., ++Next1)
                 _STDEXT unchecked_copy_backward(_First, _Next, ++_Next1);
                 *_First = _Val;
                 }
             else
                 {   // look for insertion point after first
                 for (_BidIt _First1 = _Next1;
                     _DEBUG_LT(_Val, *--_First1);
                     _Next1 = _First1)
                     *_Next1 = *_First1; // move hole down - 逐项后移
                 *_Next1 = _Val; // insert element in hole
                 }
             }
     }

 

至此，我们已经完全理解 nth_element 的算法思想了，并且明白为何它的时间复杂度和空间复杂度都很低，当不需要对某个数组进行全部排序而想找出满足某一条件（_Pred）的第 N 个值时，便可采用此算法，同时需要注意的是，此算法只对“随机访问迭代器”有效（如 vector），如果需要对 list 使用此算法，可先将 list 的所有元素拷贝至 vector（或者存储 list::iterator，对自定义类型效率更高），再使用此算法。

本文为senlie原创，转载请保留此地址：http://blog.csdn.net/zhengsenlie

nth_element
------------------------------------------------------------------------------


描述：重新排序，使得[nth,last)内没有任何一个元素小于[first,nth)内的元素，
但对于[first,nth)和[nth,last)两个子区间内的元素次序则无任何保证。
思路：
1.以 median-of-3-partition 将整个序列分割为更小的左、右子序列
2.如果 nth 迭代器落于左序列，就再对左子序列进行分割，否则就再对右子序列进行分割
3.直到分割后的子序列长大于3，对最后这个待分割的子序列做 Insertion Sort

复杂度：O(n)
源码：

 template <class RandomAccessIterator>
 inline void nth_element(RandomAccessIterator first, RandomAccessIterator nth,
                         RandomAccessIterator last) {
   __nth_element(first, nth, last, value_type(first));
 }


 template <class RandomAccessIterator, class T>
 void __nth_element(RandomAccessIterator first, RandomAccessIterator nth,
                    RandomAccessIterator last, T*) {
   while (last - first > 3) {
     //采用 median-of-3-partition 。参数：(first,last,pivot)
     //返回一个迭代器，指向分割后的右段第一个元素
     RandomAccessIterator cut = __unguarded_partition
       (first, last, T(__median(*first, *(first + (last - first)/2),
                                *(last - 1))));
     if (cut <= nth) //如果  nth 落于右段，再对右段实施分割
       first = cut;
     else  //如果 nth 落于左段，对左段实施分割
       last = cut;
   }
   __insertion_sort(first, last); //对分割后的子序列做 Insertion Sort
 }


 template <class RandomAccessIterator, class T>
 RandomAccessIterator __unguarded_partition(RandomAccessIterator first,
                                            RandomAccessIterator last,
                                            T pivot) {
   while (true) {
     while (*first < pivot) ++first;
     --last;
     while (pivot < *last) --last;
     if (!(first < last)) return first;
     iter_swap(first, last);
     ++first;
   }
 }

示例：

 int A[] = {7, 2, 6, 11, 9, 3, 12, 10, 8, 4, 1, 5};
 const int N = sizeof(A) / sizeof(int);


 nth_element(A, A + 6, A + N);
 copy(A, A + N, ostream_iterator<int>(cout, " "));
 // The printed result is "5 2 6 1 4 3 7 8 9 10 11 12".