国产精品99久久久久久宅男,色噜噜狠狠先锋影音久久,伊人久久综合无码成人网

STL 中sort源码分析

鑫龙 — Sat, 01 Jun 2013 10:53:00 GMT

转自:http://blog.csdn.net/superhackerzhang/article/details/6410670

以SGI的STL��Z��

sort有两�U�重载�Ş�?/p>

template RandomAccessIterator>

void sort(RandomAccessIterator first, RandomAccessIterator last);  
template StrictWeakOrdering> 
void sort(RandomAccessIterator first, RandomAccessIterator last,StrictWeakOrdering comp);

�q�两�U��Ş式都要求形随�����问�P代器�Q�因此只能用于容器vector或deque,�q�里我们只以�W�一�U��ؓ例进行讲�?/pre>在数据量大时�Q�采用Quick Sort�Q�分�D�递归排序�Q�一旦分�D�后的数据量���于门限值时�Q��ؓ避免递归的额外开销�Q�便采用Insertion sort�?span style="font-size: 14.44444465637207px; line-height: 25.981481552124023px; "> 
如果递归的层�ơ过深，�q�会使用Heap Sort.
对于以下的以__开头的命名函数�Q�表�C�其�����内部的其它函数调用，而不能被用户直接调用�?/pre>首先来看插入排序
 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)); }
 其所调用�?__linear_insert如下�C�：
 template 
inline void __linear_insert(_RandomAccessIter __first, 
                            _RandomAccessIter __last, _Tp*) {
  _Tp __val = *__last;
  if (__val < *__first) {
    copy_backward(__first, __last, __last + 1);
    *__first = __val;
  }else
    __unguarded_linear_insert(__last, __val);
}
 �q�里需要对其进行一下说明，通常情况下在�q�行插入排序�Ӟ��既要�q�行大小的比较，又要对边界进行控�Ӟ���l�过上面的改�q�后�Q�但只需要进行大���的比较便可�Q�这���是代码的高明这处�?/span>
 首先对要插入有序部分的元素__val与队首的最���元�?*__first�q�行比较�Q�如果__val < *__first�Q�则只__first�?__last之间的元素向后移一�?/span>位置�Q�然后将__val插入队首�?/span>
 如果__val >= *__first�Q�则说明__val在将要新生成的有序队列中不是最���，因此�Q�在下面的while中不用进行界限控�Ӟ��只比较元素的大小卛_���?/span>
 
template  
void __unguarded_linear_insert(_RandomAccessIter __last, _Tp __val) {   
  _RandomAccessIter __next = __last;  
   --__next;   
   while (__val < *__next) {     
     *__last = *__next;     
     __last = __next;     
     --__next;  
   }   
   *__last = __val; 
}
 在STL中对避免快排时每�ơ都选择最���或最大的元素做��u�Q���用以下函数选择一个三点中倹{�?/pre>template  
inline const _Tp& __median(const _Tp& __a, const _Tp& __b, const _Tp& __c) {   
  __STL_REQUIRES(_Tp, _LessThanComparable);   
  if (__a < __b)     
    if (__b < __c)       return __b;     
    else if (__a < __c)       return __c;     
    else       return __a;   
  else if (__a < __c)     return __a;   
  else if (__b < __c)     return __c;   
  else     return __b; 
}
 下面是快排中所要��用的分割函数。对[first,last)区间的元素进行分�Ԍ��使用得中轴右边的元素大于�{�于中��u�Q�左边的元素���于�{�于中��u�Q?span style="font-size: 14.44444465637207px; line-height: 25.981481552124023px; ">�q�返回中轴所在位�|��?/span>
template  
_RandomAccessIter __unguarded_partition(_RandomAccessIter __first,_RandomAccessIter __last,_Tp __pivot) {   
   while (true) {     
     while (*__first < __pivot)       ++__first;     
     --__last;     
     while (__pivot < *__last)       --__last;     
     if (!(__first < __last))       
       return __first;     
     iter_swap(__first, __last);     
     ++__first;  
    } 
}    
 sort 代码如下
template  
inline void sort(_RandomAccessIter __first, _RandomAccessIter __last) {            
  if (__first != __last) {     
    __introsort_loop(__first, __last,                      
                     __VALUE_TYPE(__first),                      
                     __lg(__last - __first) * 2);     
                     __final_insertion_sort(__first, __last);   
   } 
}
 ��Z��__lg(n)用来扑և�2^k<=n的最大k��|��用以控控刉���归的深度�?/pre>template  
inline _Size __lg(_Size __n) {   
  _Size __k;   
  for (__k = 0; __n != 1; __n >>= 1) ++__k;   
  return __k; 
}
 下面的是用来对区间��用快排，以达到部分有序状态�?/pre> template  
void __introsort_loop(_RandomAccessIter __first,                       
                      _RandomAccessIter __last, _Tp*,                       
                      _Size __depth_limit) {   
  while (__last - __first > __stl_threshold) {//__stl_threshold在这里用前面定义的常�?6�Q�当区间多于16个元素时�Q�才有必要��用快排�?br />     if (__depth_limit == 0) {//当递归的层�ơ过深时�Q���用堆排序�?      
       partial_sort(__first, __last, __last);       
       return;     
     }     
     --__depth_limit;     
     _RandomAccessIter __cut =       __unguarded_partition(__first, __last,                             
                                                           _Tp(__median(*__first,                                         
                                                           *(__first + (__last - __first)/2),                                          
                                                           *(__last - 1))));//使用分割函数�Q�反回中�?    
      __introsort_loop(__cut, __last, (_Tp*) 0, __depth_limit);//对右半部分进行递归排序     
      __last = __cut;//使尾指针指向中��u�Q�即要对左半部分排序   
    } 
}
 最后��用插入排序对各部分进行排序�?/pre> template  
void __final_insertion_sort(_RandomAccessIter __first,                              
                            _RandomAccessIter __last) {   
  if (__last - __first > __stl_threshold) {     
      __insertion_sort(__first, __first + __stl_threshold);     
      __unguarded_insertion_sort(__first + __stl_threshold, __last);   
  }   else     __insertion_sort(__first, __last); 
}
 些函数先判断元素个数是否大于16�Q�如是大于，则先用__insertion_sort()�?6个元素的子序列排序，再用__unguarded_insertion_sort()�?/pre>其余的排序。否则直接用__insertion_sort()排序�?/pre> template  
inline void __unguarded_insertion_sort(_RandomAccessIter __first,                                  
                                       _RandomAccessIter __last) {   
  __unguarded_insertion_sort_aux(__first, __last, __VALUE_TYPE(__first)); 
}  

template  
void __unguarded_insertion_sort_aux(_RandomAccessIter __first,
                                    _RandomAccessIter __last,                                     
                                    _Tp*, _Compare __comp) {   
  for (_RandomAccessIter __i = __first; __i != __last; ++__i)    
    __unguarded_linear_insert(__i, _Tp(*__i), __comp); 
}
 template  
void __unguarded_linear_insert(_RandomAccessIter __last, _Tp __val) {   
  _RandomAccessIter __next = __last;   
  --__next;   
  while (__val < *__next) {     
    *__last = *__next;     
    __last = __next;     
    --__next;   
  }   
  *__last = __val; 
}
 ps:个�h感觉__final_insertion_sort()中区分区间大���是多此一举，因�ؓ最�l�其调用的都是__unguarded_linear_insert()�Q�其�q�没用针对不
同的大小区间采用明显不用的算法�?/pre>


鑫龙 2013-06-01 18:53 发表评论

STL中mem_fun和mem_fun_ref的用法及区别(�?

鑫龙 — Tue, 25 Dec 2012 09:06:00 GMT

引子:

怎么对容器中的所有对象都�q�行同一个操作？我们可能首先惛_��的是用��@环来实现�?br />比如有如下的一个类�Q?/p>

class ClxECS{
public:
    int DoSomething() {
    cout << "Output from method DoSomething!" << endl; // �q�里以输��Z��句话来代替具体的操作
    return 0;
    };
};

现在定义如下一个vector�Q?/p>

vector vECS;

for(int i = 0; i < 13; i++){
ClxECS *pECS = new ClxECS;
vECS.push_back(pECS);
}

如果要对容器vECS中的所有对象都�q�行DoSomething()的操作，那么下面的��@环可能是首先惛_��的方案：

for(int i = 0; i < vECS.size(); i++)
vECS.at(i)->DoSomething();

当然�Q�我们也可以用iterator�Q?/p>

for(vector::iterator it = vECS.begin(); it != vECS.end(); ++it)
(*it)->DoSomething();

但是�Q�有很多C++的高手和牛�h们都会给我们一个忠告，那就是：在处理STL里面的容器的时候，��量不要自己写��@环�?br />那么�Q�我们就只好用STL��法里面的for_each了�?br />首先�Q�添加如下一个函敎ͼ�

int DoSomething(ClxECS *pECS)
{
return pECS->DoSomething();
}
然后��可以用for_each来实现我们想要的功能�Q?/p>

for_each(vECS.begin(), vECS.end(), &DoSomething);
说了半天�Q�似乎跟mem_fun和mem_fun_ref没有什么关�p�R��其实，说那么多都是��Z��引出mem_fun和mem_fun_ref。在用for_each的时候，如果我们不添加上面的那个函数�Q�该怎么办呢�Q?/p>

�q�个时候就该mem_fun和mem_fun_ref隆重��d��了。用如下�q�一行代码就行了�Q?/p>

for_each(vECS.begin(), vECS.end(), mem_fun(&ClxECS::DoSomething));
实际上就是由�q�代器去调用成员函数.

例子:

一

list lpw;
for_each(lpw.begin(), lpw.end(),mem_fun(&Widget::test)); // pw->test();

�?/p>

vector vw;
for_each(vw.begin(), vw.end(),mem_fun_ref(&Widget::test)); // w.test();

�?/p>

成员函数有参数的情况�Q�将��g��入，再bind1st为this

std::for_each(m_erased.begin(), m_erased.end(),std::bind1st(std::mem_fun(&SocketSet::_replace_with_last), this));
//相当于this->_replace_with_last(iter) //iter

两者区�?
mem_fun_ref的作用和用法跟mem_fun一��P��唯一的不同就是：

当容器中存放的是对象实体的时候用mem_fun_ref�Q?/strong>

当容器中存放的是对象的指针的时候用mem_fun�?br />

鑫龙 2012-12-25 17:06 发表评论

�q�代器特�?iterator_traits) (�?

鑫龙 — Mon, 24 Dec 2012 13:38:00 GMT
     摘要: 本文的技术可以参考本博客: Traits 技�?--- 模板元编�E?(�?    �q�代器可以区分�ؓ不同的类型，每个�c�d��都有特定的�P代器功能�?nbsp; �Ҏ��q�代器类型，��算法根据类型的不同实现出更加有效率的版本，��会�?..  阅读全文

鑫龙 2012-12-24 21:38 发表评论

c++标准�E�序�?---p258----vector�q�代器的递增和递减解析

鑫龙 — Sun, 23 Dec 2012 14:18:00 GMT
问题的由来：
vector coll;
.....
sort(++coll.begin(),coll.end());
对于sort那句�Q�如果vecotor的底层是用指针实玎ͼ�通常��是用指针实玎ͼ��Q�那么编译无法通过�?br />
其实此次问题该系列上一�ơ文章类�?lt;<c++标准�E�序�?---p55----��Z��么需要auto_ptr_ref? (�?>>,都是临时对象惹的��?br /> c++不允�怓Q何修改基本类�?包括指针)临时值的行�ؓ�Q�但对于�cȝ��型则允许。怎么理解呢？举个例子:
#include
using namespace std;

class node
{

public:
    node(int j = 0):i(j){}
    int i;
    void operator++()//�q�里重定义一个赋值操作符=,��Z��面的赋值做准备�?/span>
    {
        i++;
    }
};

node fun()
{
    node temp(1);
    return temp;//�q�里�q�回一个类的��时变�?/span>
}

int* fun2()
{
    int a =1;
    int* b = &a;  //�q�里�q�回存在栈中局部变量的地址是不对的�Q�但只是做实验！
    return b;//�q�里�q�回一个普通int临时变量

}
int main()
{
    ++fun();   // ok!
    ++fun2(); //�q�句无法通过�~�译
    system("pause");

}
上面的例子fun()�q�回�cȝ��型的临时变量可以被修改，但fun2()�q�回的指针的临时变量不能被修攏V�?br /> 回到开始的例子,因�ؓvector的�P代器底层是用指针实现�Q�所以begin()函数�q�回的是一个指针类型的临时变量�Q�如果用++操作��M��改，那就�q�反了c++的设计原则，所以无法编译通过。做到底�q�是左��g��能被修改!!!

鑫龙 2012-12-23 22:18 发表评论

c++标准�E�序�?---p55----��Z��么需要auto_ptr_ref? (�?

鑫龙 — Sun, 16 Dec 2012 08:06:00 GMT
     摘要: �q�几天开始拜��M��捷先生和孟岩先生的译作《C++标准�E�序库：自修教程与参考手册�?nbsp;。两位先生确实译功上乘，��d��很顺。但是读到P55��关于auto_ptr_ref的讨论，却百思不得其解：��Z��么需要引入auto_ptr_ref�q�个辅助�c�d��Q?nbsp;从书中描�q�来看，仿佛与拷贝构造函�?nbsp;、右�?nbsp;、类型�{�?nbsp;有关。于是，�l�合auto_ptr的源代码�Q�google之�?..  阅读全文

鑫龙 2012-12-16 16:06 发表评论