经典排序算法和C++ stl 排序算法

最新推荐文章于 2022-02-22 21:42:36 发布

weixin_33770878

最新推荐文章于 2022-02-22 21:42:36 发布

阅读量76

点赞数

文章标签： c/c++ python 数据结构与算法

原文链接：https://my.oschina.net/OkamiLiu/blog/417874

版权

2019独角兽企业重金招聘Python工程师标准>>>

经典排序算法和C++ stl 排序算法

1.经典排序算法

1.1 冒泡排序

1.2 选择排序

1.3 直接插入排序

1.4 归并排序

1.5 快速排序

1.6 希尔排序

1.7 堆排序

2. C++ stl 排序算法

2.1 sort

3. inline

1.经典排序算法

1.1冒泡排序

何为冒泡排序？即像冒泡一样，将大数放在前面，小数放在后面，像冒泡一样的排序方式。

那么冒泡排序的原理又是什么呢？冒泡算法的基本原理是：依次比较相邻的两个数，将较大数放在前面，较小数放在后面。即比较第1个和第2个数，将大数放前，小数放后，再接着比较第2个数和第3个数，将大数放前，小数放后，如此继续，直到比较最后2个数。此时，第1轮结束，如此，在第1轮之后，位于最后的数必是最小的数。然后使用上一轮的结果重复第一轮的过程，将所有的最小数都放在后面。到所有的数都已经有序时，算法结束。

算法实现：

 
void BubbleSort(int *pData,int Count)  
{ 
     int iTemp; 
     for(int i=1;i<Count;++i) 
     { 
         for(int j=Count-1;j>=i;j--) 
         { 
             if(pData[j]<pData[j-1]) 
             { 
                 iTemp = pData[j-1]; 
                 pData[j-1] = pData[j]; 
                 pData[j] = iTemp;  
              }  
          } 
      }  
} 
  

ps:冒泡排序效率还可以优化。

1.2 选择排序

何为选择排序呢？即：从需要排序的队列中，选择最小的数同第一个交换，再从剩下的队列中选择最小的数同第二个交换，循环执行下去，直到实现全队列的排序。

算法实现：

 
void SelectSort(int *pData, int Count) 
{ 
     int iTemp; 
     int iPos; 
     for (int i = 0; i < Count - 1; i++) 
     { 
         iTemp = pData[i]; 
         iPos = i; 
         for (int j = i + 1; j < Count; j++) 
         { 
             if (pData[j] < iTemp) 
             { 
                 iTemp = pData[j]; 
                 iPos = j; 
             } 
         } 
         pData[iPos] = pData[i]; 
         pData[i] = iTemp; 
     } 
} 
  

1.3 直接插入排序

何为直接插入排序呢？这种排序较为复杂，它的基本工作原理是：可以做个比喻，抽出牌，在前面的牌中找到适合的位置插进去。

算法实现：

 
void InsertSort(int *pData, int Count) 
{ 
     int iTemp; 
     int iPos; 
     for (int i = 0; i < Count; i++) 
     { 
         iTemp = pData[i]; 
         iPos = i - 1; 
         while(iPos >= 0 && iTemp < pData[iPos]) 
         { 
             pData[iPos + 1] = pData[iPos]; 
             iPos--; 
         } 
         pData[iPos + 1] = iTemp; 
     } 
} 
  

1.4 归并排序

何为归并排序呢？归并排序是建立在归并操作上的一种有效的排序算法,该算法是采用分治法的一个非常典型的应用。

算法实现，不予以给出。此处不作重点。

1.5 快速排序

何为快速排序呢？算法通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。

一趟快速排序的算法是：

1）设置两个变量i、j，排序开始的时候：i=0，j=N-1；

2）以第一个数组元素作为关键数据，赋值给key，即key=A[0]；

3）从j开始向前搜索，即由后开始向前搜索(j--)，找到第一个小于key的值A[j]，将A[j]和A[i]互换；

4）从i开始向后搜索，即由前开始向后搜索(i++)，找到第一个大于key的A[i]，将A[i]和A[j]互换；

5）重复第3、4步，直到i=j； (3,4步中，没找到符合条件的值，即3中A[j]不小于key,4中A[i]不大于key的时候改变j、i的值，使得j=j-1，i=i+1，直至找到为止。找到符合条件的值，进行交换的时候i， j指针位置不变。另外，i==j这一过程一定正好是i+或j-完成的时候，此时令循环结束）。

算法实现：

 
void Qsort(int a[], int low, int high) { 
     if (low >= high) 
     { 
         return; 
     } 
     int first = low; 
     int last = high; 
     int key = a[first]; 
     while (first < last) 
     { 
         while (first < last && a[last] >= key) 
         { 
             --last; 
         } 
         a[first] = a[last]; 
         while (first < last && a[first] <= key) 
         { 
             ++first; 
         } 
         a[last] = a[first]; 
     } 
     a[first] = key; 
     Qsort(a, low, first - 1); 
     Qsort(a, first + 1, high); 
} 
  

1.6 希尔排序

何为希尔排序呢？希尔排序(Shell Sort)是插入排序的一种。也称缩小增量排序，是直接插入排序算法的一种更高效的改进版本。

1.7 堆排序

何为堆排序呢？堆排序(Heapsort)是指利用堆积树（堆）这种数据结构所设计的一种排序算法，它是选择排序的一种。

堆排序原理：堆排序利用了大根堆（或小根堆）堆顶记录的关键字最大（或最小）这一特征，使得在当前无序区中选取最大（或最小）关键字的记录变得简单。

算法实现：

 
//本函数功能是：根据数组array构建大根堆  
void HeapAdjust(int array[],int i,int nLength) 
{    
     int nChild;     
     int nTemp;     
     for(;2*i+1<nLength;i=nChild)     
     {         //子结点的位置=2*（父结点位置）+1      
         nChild=2*i+1;         //得到子结点中较大的结点        
         if(nChild<nLength-1&&array[nChild+1]>array[nChild])++nChild;     
         //如果较大的子结点大于父结点那么把较大的子结点往上移动，替换它的父结点         
         if(array[i]<array[nChild])      
         {           
             nTemp=array[i];        
             array[i]=array[nChild];       
             array[nChild]=nTemp;         
         } 
         else break; //否则退出循环      
     } 
} 
//堆排序算法 
void HeapSort(int array[],int length) 
{     
     int i;     //调整序列的前半部分元素，调整完之后第一个元素是序列的最大的元素     //length/2-1是最后一个非叶节点，此处"/"为整除     
     for(i=length/2-1;i>=0;--i)    
         HeapAdjust(array,i,length);   
     //从最后一个元素开始对序列进行调整，不断的缩小调整的范围直到第一个元素      
     for(i=length-1;i>0;--i)    
     {         //把第一个元素和当前的最后一个元素交换，         //保证当前的最后一个位置的元素都是在现在的这个序列之中最大的    
         array[i]=array[0]^array[i];       
         array[0]=array[0]^array[i];      
         array[i]=array[0]^array[i];         //不断缩小调整heap的范围，每一次调整完毕保证第一个元素是当前序列的最大值        
         HeapAdjust(array,0,i);    
     } 
} 
  

2 C++ STL 排序算法

2.1 sort

sort是stl标准库提供的，比较高效的算法。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); 
     } 
  
// TEMPLATE FUNCTION sort 
template<class _RanIt> inline 
void sort(_RanIt _First, _RanIt _Last) 
{    // order [_First, _Last), using operator< 
     _STD sort(_First, _Last, less<>()); 
} 
  

首先，我们来看sort函数的声明。stl为sort提供了2个版本的声明，一个是只有2个迭代器参数的声明，一个是除了2个迭代器参数之外还有一个用于使用<的一个方法。即：第2版本的sort的第3个参数可以是一个Compare算法的函数。

这里就要注意了：

第一点：这个2个迭代器参数的使用，sort的参数要求，你传进来的2个迭代器参数必须是随机的迭代器，这样才能保证内部算法的赋值等其他的操作的实现，所以，这个迭代器应该是一个随机的可读可写的迭代器。（ps：这里为什么不使用指针，而是使用迭代器呢？那是因为迭代器是一种抽象的对象，它能够遍历标准模版库中的容易的部分或全部元素。这样可以更加高效的执行算法。）

第二点：在sort的第2个版本中的第3个参数，我们就叫它compare参数吧（不是正规叫法哈），它是采用严格弱排序，严格是是说，在判断的时候会用“<” ，弱排序是因为一旦“<” 成立便认为存在“<”关系，返回true，而忽略“=”和“>”关系，返回false，这也是执行sort不保证稳定性的原因。

下面是sort方法中的定义：

2.1.1sort中的快排

 
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; 
         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; 
             } 
         } 
  
         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) 
             _Insertion_sort(_First, _Last, _Pred);    // small 
     } 
  

2.1.2 sort中的插入排序

 
template<class _BidIt, 
     class _Pr> inline 
     void _Insertion_sort(_BidIt _First, _BidIt _Last, _Pr _Pred) 
     {    // insertion sort [_First, _Last), using _Pred 
     _Insertion_sort1(_First, _Last, _Pred, _Val_type(_First)); 
     } 
template<class _BidIt, 
     class _Pr, 
     class _Ty> inline 
     void _Insertion_sort1(_BidIt _First, _BidIt _Last, _Pr _Pred, _Ty *) 
     {    // insertion sort [_First, _Last), using _Pred 
     if (_First != _Last) 
         for (_BidIt _Next = _First; ++_Next != _Last; ) 
             {    // order next element 
             _BidIt _Next1 = _Next; 
             _Ty _Val = _Move(*_Next); 
  
             if (_DEBUG_LT_PRED(_Pred, _Val, *_First)) 
                 {    // found new earliest element, move to front 
                 _Move_backward(_First, _Next, ++_Next1); 
                 *_First = _Move(_Val); 
                 } 
             else 
                 {    // look for insertion point after first 
                 for (_BidIt _First1 = _Next1; 
                     _DEBUG_LT_PRED(_Pred, _Val, *--_First1); 
                     _Next1 = _First1) 
                     *_Next1 = _Move(*_First1);    // move hole down 
                 *_Next1 = _Move(_Val);    // insert element in hole 
                 } 
             } 
     } 
  

2.1.3 sort中的堆排序1 建堆算法

 
template<class _RanIt, 
     class _Pr> inline 
     void make_heap(_RanIt _First, _RanIt _Last, _Pr _Pred) 
     {    // make [_First, _Last) into a heap, using _Pred 
     _DEBUG_RANGE(_First, _Last); 
     _DEBUG_POINTER(_Pred); 
     if (1 < _Last - _First) 
         _Make_heap(_Unchecked(_First), _Unchecked(_Last), _Pred, 
             _Dist_type(_First), _Val_type(_First)); 
     } 
template<class _RanIt, 
     class _Diff, 
     class _Ty, 
     class _Pr> inline 
     void _Make_heap(_RanIt _First, _RanIt _Last, _Pr _Pred, _Diff *, _Ty *) 
     {    // make nontrivial [_First, _Last) into a heap, using _Pred 
     _Diff _Bottom = _Last - _First; 
     for (_Diff _Hole = _Bottom / 2; 0 < _Hole; ) 
         {    // reheap top half, bottom to top 
         --_Hole; 
         _Ty _Val = _Move(*(_First + _Hole)); 
         _Adjust_heap(_First, _Hole, _Bottom, 
             _Move(_Val), _Pred); 
         } 
     } 
  

2.1.3 sort中的堆排序2 堆排序算法

 
template<class _RanIt, 
     class _Pr> inline 
     void sort_heap(_RanIt _First, _RanIt _Last, _Pr _Pred) 
     {    // order heap by repeatedly popping, using _Pred 
     _DEBUG_RANGE(_First, _Last); 
     _DEBUG_POINTER(_Pred); 
     _DEBUG_HEAP_PRED(_First, _Last, _Pred); 
     _Sort_heap(_Unchecked(_First), _Unchecked(_Last), _Pred); 
     } 
  
template<class _RanIt, 
     class _Pr> inline 
     void _Sort_heap(_RanIt _First, _RanIt _Last, _Pr _Pred) 
     {    // order heap by repeatedly popping, using _Pred 
     for (; 1 < _Last - _First; --_Last) 
         _Pop_heap(_First, _Last, _Pred); 
     } 
  
  