C++STL排序

STL中的排序函数

1.Sort函数

功能:对给定的区间所有元素进行排序

排序算法:快速排序，堆排序，插入排序

快速排序的最优时间复杂度：O(nlogn)，最差时间复杂度为：O(n^2)

插入排序的最优时间复杂度：O(N)，最差时间复杂度为：O(N^2)

堆排序的最优时间复杂度为：O(nlogn)，最差时间复杂度为：O(nlogn)

源码:

//1.快速排序

//2.堆排序

//3.插入排序

template <class _RandomAccessIter>

inline void sort(_RandomAccessIter __first, _RandomAccessIter __last) {

  if (__first != __last) {

  //混合排序

  //1.快速排序

  //2.堆排序

    __introsort_loop(__first, __last,

                     __VALUE_TYPE(__first),

//快速排序最大递归深度

                     __lg(__last - __first) * 2);

//插入排序

    __final_insertion_sort(__first, __last);

  }

}

//混合排序算法，内省式排序

//1.元素个数小于__stl_threshold个，结束内省式排序，返回sort函数，改用插入排序

//2.元素个数大于__stl_threshold个，如果递归深度超过最大层次的递归调用，

//说明快速排序不合适，使用partial_sort堆排序

//3.若是没有超过最大递归调用深度，调用函数unguarded_partition对当前元素快速排序，并返回位置。

template <class _RandomAccessIter, class _Tp, class _Size>

void __introsort_loop(_RandomAccessIter __first,

                      _RandomAccessIter __last, _Tp*,

                      _Size __depth_limit)

{

  while (__last - __first > __stl_threshold) {

    if (__depth_limit == 0) {

      partial_sort(__first, __last, __last);

      return;

    }

    --__depth_limit;

    _RandomAccessIter __cut =

      __unguarded_partition(__first, __last,

                            _Tp(__median(*__first,

                                         *(__first + (__last - __first)/2),

                                         *(__last - 1))));

//右半部分使用递归内省式排序

    __introsort_loop(__cut, __last, (_Tp*) 0, __depth_limit);

//左半部分直接回到while函数

    __last = __cut;

  }

}

//插入排序

template <class _RandomAccessIter>

void __final_insertion_sort(_RandomAccessIter __first,

                            _RandomAccessIter __last) {

  if (__last - __first > __stl_threshold) {//16

    __insertion_sort(__first, __first + __stl_threshold);

//双循环 ，在个元素的基础 上，依次添加元素，不会比较 第一个元素

    __unguarded_insertion_sort(__first + __stl_threshold, __last);

  }

  else

  //小于个插入排序，调 用插入排序

  //双循环 ，在个元素的基础 上，依次添加元素，会和数据中第一个元素first比较     __insertion_sort(__first, __last);

}

template <class _Size>

inline _Size __lg(_Size __n) {

  _Size __k;

  for (__k = 0; __n != 1; __n >>= 1) ++__k;

  return __k;

}

//插入排序

//在迭代器last之前插入数据val，使之按照升序排列

//直接从元素尾判断

template <class _RandomAccessIter, class _Tp>

void __unguarded_linear_insert(_RandomAccessIter __last, _Tp __val) {

  _RandomAccessIter __next = __last;

  --__next;

  while (__val < *__next) {

    *__last = *__next;

    __last = __next;

    --__next;

  }

  *__last = __val;

}

//插入排序

//在[first,last]中国对数据重新排序，使之按照升序排列

//先判断first元素

template <class _RandomAccessIter, class _Tp>

inline void __linear_insert(_RandomAccessIter __first,

                            _RandomAccessIter __last, _Tp*) {

  _Tp __val = *__last;

  //如果last数据小于first数据，整个区间右移一位，并且first等于last

  //last+1中是不是还 是之前的last数据?

  if (__val < *__first) {

    copy_backward(__first, __last, __last + 1);

    *__first = __val;

  }

  else

  //如果last数据大于first，调 用之前函数将，最后一个函数插入列表，升序排序

    __unguarded_linear_insert(__last, __val);

}

//插入排序

//以first为第一个数据，依次插入列表中的数据，通过函数linear_insert升序排列

template <class _RandomAccessIter>

void __insertion_sort(_RandomAccessIter __first, _RandomAccessIter __last) {

  if (__first == __last) return;

  for (_RandomAccessIter __i = __first + 1; __i != __last; ++__i)

    __linear_insert(__first, __i, __VALUE_TYPE(__first));

}