stl源码剖析 详细学习笔记 算法(4)

//---------------------------15/03/31----------------------------

//lower_bound(要求有序)

template<class ForwardIterator,
class T>

inline ForwardIterator lower_bound(ForwardIterator first,

ForwardIterator last,

const T& value)

{

return __lower_bound(first, last, value, distance_type(first),

iterator_category(first));

}

//采用二分法来寻找第一个允许插入的位置

template<class ForwardIterator,
class T, class Distance>

ForwardIterator __lower_bound(ForwardIterator first,

ForwardIterator last,

const T& value, Distance*

forward_iterator_tag)

{

Distance len =
0;

//取到数组大小len

distance(first, last, len);

Distance half;

ForwardIterator middle;

while (len > 0)

{

//找到中间的位置，取”下界“，然而其实是取half＋1，因为这里是first+half

//虽然取的是下界
比如len=3
取到half＝1， first+1
就是第2个

half = len >>
1;

middle = first;

advance(middle, half);

if(*middle < value)

{

first = middle;

++first;

//first一开始指向 half＋1的元素，所以右边剩下的是 len－half－1

len = len - half -
1;

}

else

len = half;

}

return first;

}

//其实感觉没有必要使用两个版本，distance函数和advance函数底层就已经对迭代器进行分类运算了

//效率上应该不会差的。

template<class RandomAccessIterator,
class T, class Distance>

RandomAccessIterator __lower_bound(RandomAccessIterator first,

RandomAccessIterator last,

const T& value, Distance*,

random_access_iterator_tag)

{

Distance len = last - first;

Distance half;

RandomAccessIterator middle;

while (len > 0)

{

half = len >>
1;

middle = first + half;

if(*middle < value)

{

first = middle +
1;

len = len - half -
1;

}

else

len = half;

}

return first;

}

//upper_bound(要求有序)

template<class ForwardIterator,
class T>

inline ForwardIterator upper_bound(ForwardIterator first,

ForwardIterator last,

const T& value)

{

return __upper_bound(first, last, value, distance_type(first),

iterator_category(first));

}

template<class ForwardIterator,
class T, class Distance>

ForwardIterator __upper_bound(ForwardIterator first,

ForwardIterator last,

const T& value, Distance*

forward_iterator_tag)

{

Distance len =
0;

//取到数组大小len

distance(first, last, len);

Distance half;

ForwardIterator middle;

while (len > 0)

{

//和lower_bound不一样，当 value
等于 middle
时是向右走的。所以指向

//的位置的值不是value，而是第一个大于value的值

half = len >>
1;

middle = first;

advance(middle, half);

if(value < *middle)

len = half;

else

{

first = middle;

++first;

len = len - half -
1;

}

}

return first;

}

template<class RandomAccessIterator,
class T, class Distance>

RandomAccessIterator __upper_bound(RandomAccessIterator first,

RandomAccessIterator last,

const T& value, Distance*,

random_access_iterator_tag)

{

Distance len = last - first;

Distance half;

RandomAccessIterator middle;

while (len > 0)

{

half = len >>
1;

middle = first + half;

if(value < *middle)

len = half;

else

{

first = middle+1;

len = len -half -1;

}

}

return first;

}

//binary_search(要求有序)

template<class ForwardIterator,
class T>

bool binary_search(ForwardIterator first, ForwardIterator last,

const T& value)

{

ForwardIterator i =lower_bound(first, last, value);

return i != last && !(value < *i);

//如果不存在，使用lower_bound获得的*i > value;所以如果value < *i说明没找到

}

template<class ForwardIterator,
class T, class Compare>

bool binary_search(ForwardIterator first, ForwardIterator last,

const T& value, Compare comp)

{

ForwardIterator i = lower_bound(first, last, value, comp);

return i != last && !comp(value, *i);

}

//next_permutation

/*

下一个排列组合：

abc，acb，bac，bca，cab，cba。依次排序，前面的元素最迟改变，

把后面的都排序一遍，当前面的元素改变时，最后的元素要依次排序

acbd的 b<d，所以固定前面元素，得到acdb，再下一个 d>b c < d所以可以让c
变成d
得到adbc

*/

template<class BidirectionalIterator>

bool next_permutation(BidirectionalIterator first,

BidirectionalIterator last)

{

if(first == last)

return false;

BidirectionalIterator i = first;

++i;

if(i == last)

return false;

//区间没有元素和只有一个元素都返回false；

i = last;

-- i;

//i＝最后一个元素

for(;;)

{

//ii成了最后一个元素

BidirectionalIterator ii = i;

//i成了最后一个元素的前驱

--i;

//只要不是成倒序的就可以找到 *i < *ii，如果是倒序的说明没有下一个排列组合了

if(*i < *ii)

{

/*

现在情况是 i d c... j
首先 d > c >... > j

i < d 。因为后面都是倒序的，我们要找到一个比i大一阶的数填到i的位置。

所以while(!(*i < *--j)只要j小于等于i就左走，找到一个大于i的就可以把

这个数放入i的位置，把i放入j的位置。i放到j的位置。d开始到末尾的序列还是倒序的

所以要reverse( d c ... last)d就是ii在的位置

*/

BidirectionalIterator j =last;

while(!(*i < *--j));

iter_swap(i, j);

reverse(ii, last);

return true;

}

if(i == first)

{

//整个序列时倒序的，直接把它变成正序就好了。并要返回false

reverse(first, last);

return false;

}

}

}

//prev_permutation

template<class BidirectionalIterator>

bool prev_permutation(BidirectionalIterator first,

BidirectionalIterator last)

{

if(first == last)

return false;

BidirectionalIterator i = first;

++i;

if(i == last)

return false;

i = last;

--i;

//和next操作刚好相反，先找到一个数比他后驱大，再找到比他小一阶的数交换，之后反转

for(;;)

{

BidirectionalIterator ii = i;

--i;

if(*ii < *i)

{

BidirectionalIterator j =last;

while(!(*--j < *i));

iter_swap(i, j);

reverse(ii, last);

return true;

}

if(i == first)

{

reverse(first, last);

return false;

}

}

}

//random_shuffle

//对区间[first,last)随机产生一个排列

template<class RandomAccessIterator>

inline void random_shuffle(RandomAccessIterator first,

RandomAccessIterator last)

{

__random_shuffle(first, last, distance_type(first));

}

template<class RandomAccessIterator,
class Distance>

void __random_shuffle(RandomAccessIterator first,

RandomAccessIterator last,

Distance*)

{

if(first == last)

return;

for(RandomAccessIterator i =first +
1; i != last; ++i)

#ifdef __STL_NO_DRAND48

iter_swap(i, first + Distance(rand()%((i - first) +
1)));

#else

iter_swap(i, first + Distance(lrand48() % ((i - first) +
1)));

#endif

}

template<class RandomAccessIterator,
class RandomNumberGenerator>

void random_shuffle(RandomAccessIterator first, RandomAccessIterator last,

RandomNumberGenerator& rand)

{

if(first == last)

return;

for(RandomAccessIterator i = first +
1; i != last; ++i)

iter_swap(i, first + rand((i - first) +
1));

}

//partial_sort

//基于堆来对前面部分数据进行排序

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>

void __partial_sort(RandomAccessIterator first,

RandomAccessIterator middle,

RandomAccessIterator last,T*)

{

make_heap(first, middle);

for(RandomAccessIterator i = middle; i < last; ++i)

{

if(*i < *first)

__pop_heap(first, middle, i, T(*i), distance_type(first));

sort_heap(first, middle);

}

}

//sort

//Insetion Sort

template<class RandomAccessIterator>

void __insertion_sort(RandomAccessIterator first,

RandomAccessIterator last)

{

if(first == last)

return ;

for(RandomAccessIterator i =first +
1; i != last; ++i)

__linear_insert(first, i,value_type(first));

}

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;

//不用判断越界，前面已经保证头部是最小的了

while (value < *next)

{

*last = *next;

last = next;

--next;

}

*last = value;

}

//取中间值

template<class T>

inline const T& __median(const T& a,
const T& b, const T& c)

{

if(a < b)

if(b < c)

return b; //a < b < c

else if(a < c)

return c; //a < b, b >= c, a<c

else

return a;

else if(a < c)
//c > a >=b

return a;

else
if(b < c)
// a >=b, a <= c, b < c

return c;

else

return b;

}

//很正常的快排划分步骤最后得到的结果是 first后面包括first的值是大于等于pivot值的

//first前面的值是小于pivot值的

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;

}

}

//真正的sort

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);

}

}

template<class Size>

inline Size __lg(Size n)

{

Size k;

for(k = 0; n >
1; n >>= 1)

++k;

return k;

}

template<class RandomAccessIterator,
class T, class Size>

void __introsort_loop(RandomAccessIterator first,

RandomAccessIterator last, T*,

Size depth_limit)

{

//__stl_treshold
是全局常数 为const int 16

while (last - first > __stl_threshold)

{

if (depth_limit ==
0)

{

//如果调用深度到达限制就改调用堆排序

partial_sort(first, last, last);

return;

}

//深度减一

--depth_limit;

//调用一次划分返回
关键元素的迭代器

RandomAccessIterator cur = __unguarded_partition(

first, last, T(__median(*first,

*(first + (last - first) /
2),

*(last -
1))));

//对右边进行迭代

__introsort_loop(cur, last, value_type(first), depth_limit);

last = cur;

}

}

template<class RandomAccessIterator>

void __final_insertion_sort(RandomAccessIterator first,

RandomAccessIterator last)

{

if (last - first > __stl_threshold)

{

__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));

}

/*

sort总结：先采用快排，有两种情况产生：

1>深度没有超出极限，会诞生一个个区间，每个区间大小
小于等于__stl_threshold(默认为16)，

然后对前16个采用插入排序，需要判断尾元素是否小于first元素。这次调用完就确保first是最小的

然后再调用__unguarded_linear_sort就可以少一个判断，也就可以从first + __stl_threshold

的地方进行开始调用__unguared_linear_sort，插入位置会一直往左，有可能会越过first + __stl_threshold

的位置。

(ps:一开始我想不明白的一点是，如果先对前16个元素调用一次__unguarded_linear_insert，那如果当初划分时

前面13个(只要小于16就行)是一个区间，那不是会把后面的3个元素牵扯进来，如果后面的3个元素不是最小的三个

那排序不就失败了，我当时想的是final sort那调用__unguarded_linear_insert(first +__stl_threshold, last)

会以first +__stl_threshold为first区间，对之后的所有元素进行排序，会造成一个问题，前16个中有比后面

大的元素。后来才发现sgi的奇妙设计，那个while (value < *next),并没有越界判断，所以会一直往左搜索。)

2>迭代深度超出限制，会对之后迭代的区间进行堆排序，这时剩下的区间就是不确定的，有已经排序好的(深度超出限制)，

也有没排序的(快排迭代达到16个元素的)，再次调用插入排序，对所有区间整理一遍。

*/

//equal_range(要求有序)

//返回由
等于传入值 的元素
组成的区间

template<class ForwardIterator,
class T>

inline pair<ForwardIterator, ForwardIterator>

equal_range(ForwardIterator first, ForwardIterator last,

const T& value)

{

return __equal_range(first, last, value, distance_type(first),

iterator_category(first));

}

template<class RandomAccessIterator,
class T, class Distance>

pair<RandomAccessIterator, RandomAccessIterator>

__equal_range(RandomAccessIterator first, RandomAccessIterator last,

const T& value, Distance*, random_access_iterator_tag)

{

Distance len = last - first;

Distance half;

RandomAccessIterator middle, left, right;

while (len > 0)

{

half = len >>
1;

middle = first + half;

if(*middle < value)

{

first = middle +
1;

len = len - half -1;

}

else if(value < *middle)

len = half;

else

{

left = lower_bound(first, middle, value);

right = upper_bound(++middle, first + len, value);

return pair<RandomAccessIterator, RandomAccessIterator>(left, right);

}

//因为lower_bound和upper_bound都会调用同样的步骤直到相等。

}

return pair<RandomAccessIterator, RandomAccessIterator>(first, first);

//在没有value值的情况下，返回一个区间[first,first)也就是first＝last的情况，这样可以表示

//没有相应元素。

}

template<class ForwardIterator,
class T, class Distance>

pair<ForwardIterator, ForwardIterator>

__equal_range(ForwardIterator first, ForwardIterator last,

const T& value, Distance*, forward_iterator_tag)

{

Distance len = last - first;

Distance half;

ForwardIterator middle, left, right;

while (len > 0)

{

half = len >>
1;

middle = first;

advance(middle, half);

if(*middle < value)

{

first = middle;

++first;

len = len - half -1;

}

else if(value < *middle)

len = half;

else

{

left = lower_bound(first, middle, value);

advance(first, len);

right = upper_bound(++middle, first, value);

return pair<ForwardIterator, ForwardIterator>(left, right);

}

}

return pair<ForwardIterator, ForwardIterator>(first, first);

}