十大排序及C++实现

No.1 冒泡排序

　　从左至右依次消除相邻逆序对。

void swap(int &a, int &b)
{
    int temp = a;
    a = b;
    b = temp;
}
void bubble_sort(int *array,int length)
{
    for( int i=0; i<length-1; i++ )
    {
        for( int j=0; j<length-i-1; j++ )
        {
            if( array[j]>array[j+1] )
            {
                swap(array[j],array[j+1]);
            }
        }    
    }    
}

　　每次内层循环后最大值都来到未排序数组最右端，就像大泡泡依次向上冒出。

　　双重循环，时间复杂度O(n^2)。

　　冒泡排序简单易理解，但每次都不管三七二十一直接两重循环。一个优化方法是每次内层循环都判断剩余数组是否有序，若有序则排序完成。

void bubble_sort(int *array,int length)
{
    for( int i=0; i<length-1; i++ )
    {
        bool is_sorted = true;
        for( int j=0; j<length-i-1; j++ )
        {
            if( array[j]>array[j+1] )
            {
                swap(array[j],array[j+1]);
                is_sorted = false;
            }
        }    
        if( is_sorted )    break;
    }    
} 

 

---

 

 

No.2 选择排序

　　每次选择最小值，将其与未排序数组最左端交换。即每次内层循环都在未排序数组中使用FindMin()函数，并与未排序数组左端交换。

void select_sort(int *array,int length)
{
    for( int i=0; i<length-1; i++ )
    {
        int min = i; //array[i,...,length]最小值下标 
        for( int j=i+1; j<length; j++ )
        {
            if( array[min]>array[j] ){
                min = j;
            }
        }
        swap(array[i],array[min]);
    }
}

　　双重循环，时间复杂度O(n^2)。

 

---

 

 

No.3 插入排序

　　算法过程类似于打扑克抓手牌，每次从牌堆抓一张牌后，从右至左在手牌中找到合适位置插入新手牌，保持手牌有序。

void insert_sort( int *array, int length )
{
    for( int i=1; i<length; i++ )
    {
        int j = i - 1;
        int key = array[i]; /*暂时保存新的手牌 */ 
        while( j>=0 && array[j]>key )/*找到合适位置*/ 
        {
            array[j+1] = array[j];
            j--;
        }
        array[j+1] = key; /*将新手牌放入合适位置*/ 
    }
}

　　在最好情况即有序情况下时间复杂度为外层循环O(n)，在最坏情况下即逆序情况下时间复杂度为双重循环O(n^2)。

 

---

 

 

No.4 希尔排序

　　插入排序的改进版本，又称为缩减增量排序。其思想是每次用增量ht(>=1)作为间隔将数组划分为子问题进行插入排序，每次排序后增量缩减，

重复上述过程，直到增量减为1，此时的排序与插入排序相同。

void shell_sort( int *array, int length )
{
    /*计算初始增量*/
    int gap = 1;
    while( gap<length )    gap = gap * 3 + 1;
    /*以增量为间隔排序*/
    while( gap>0 )
    {
        for( int i=gap; i<length; i++ )
        {
            /*当gap=1时程序与插入排序相同*/
            int j = i - gap;
            int key = array[i];
            while( j>=0 && array[j]>key )
            {
                array[j+gap] = array[j];
                j -= gap;
            }
            array[j+gap] = key;
        }
        gap /= 3; /*增量递减*/
    }
}

　　通过将完全无序的初始序列，通过缩减增量逐步将序列有序，最后一步的插入排序只需交换个别元素位置，使时间复杂度优于插入排序。

　　增量的初值及缩减规则没有最优标准。

 

---

 

 

No.5 归并排序

　　分治法思想，即划分，排序，合并。每次将序列两两分组，直至序列长度为1，接着逐步合并子序列并保持合并序列有序。

const int INF = 10000000;
void merge(int *array, int p, int q, int r )
{
    int length1 = q - p + 1, length2 = r - q;
    int *A = new int[length1+1];
    int *B = new int[length2+1]; //临时数组
    
    for( int i=p; i<=q; i++ )
    {
        A[i-p] = array[i];    
    }    
    for( int i=q+1; i<=r; i++ )
    {
        B[i-q-1] = array[i];
    }
    A[length1] = B[length2] = INF; //为统一操作 
    
    int i = 0, j = 0;
    for( int k=p; k<=r; k++ )
    {
        if( A[i]<B[j] )
        {
            array[k] = A[i];
            i++; 
        }
        else
        {
            array[k] = B[j];
            j++;
        }
    }
    
    delete []A;    delete []B; //释放内存 
}

void merge_sort( int *array, int p, int r )
{
    if( p<r )
    {
        int q = (p+r)/2;
        merge_sort(array,p,q);
        merge_sort(array,q+1,r);
        merge(array,p,q,r);
    }
}

　　算法每次将问题划分为两个相等的子问题，合并与排序同时进行，需要O(n)时间。

　　T(n)  = 2T(n/2) + O(n)  =  T(nlogn)。

 

---

 

 

No.6 快速排序

　　分治法思想，每次在序列中选取一个基准值，经过一次排序操作后，位于基准值左边的元素不大于基准值、位于基准值右边的元素不小于基准值。

接着在基准值左右两边分别选取新的基准值重复操作，直到左右元素个数不大于1，序列排序完成。

　　基准值的选取影响算法时间的好坏，这里统一选取数组的最右端作为基准值。

　　找到基准值后对元素的划分有多种方法。

　　单边扫描法：从左至右遍历元素，若元素小于基准值，则与左端元素交换。

int patition( int *array, int p, int r )
{
    int x = array[r]; //以最右端元素作为基准值
    int i = p - 1;
    for( int j=p; j<r; j++ )
    {
        if( array[j]<x )
        {/*将小于基准值元素放在左边*/
            i++;
            swap(array[i],array[j]);    
        }    
    }
    swap(array[i+1],array[r]);
    return i+1; 
}

void quick_sort( int *array, int p, int r )
{
    if( p<r )
    {
        int q = patition(array,p,r);
        quick_sort(array,p,q-1);
        quick_sort(array,q+1,r);
    }
}

　　双边扫描法：先从左至右找到大于基准值元素，再从右至左找到小于基准值元素，交换元素，重复上述过程直至左右指针相遇。

int patition( int *array, int p, int r )
{
    int x = array[r]; //以最右端元素作为基准值
    int i = p, j = r - 1;
    while( i<=j )
    {/* 保证i左边的元素<=x,j右边元素(不包括r)>=x */
        while( i<=j && array[i]<=x )    i++;
        while( i<=j && array[j]>=x )    j--;
        if( i<=j )
        {
            swap(array[i],array[j]);    
        }    
    } 
    /* 此时array[i]>x */
    swap(array[r],array[i]);
    return i; 
}

void quick_sort( int *array, int p, int r )
{
    if( p<r )
    {
        int q = patition(array,p,r);
        quick_sort(array,p,q-1);
        quick_sort(array,q+1,r);
    }
}

　　快排在最坏情况下:每次划分后一段元素个数为0，另一端为length-1 时间复杂度为O(n^2)，在一般情况下时间复杂度为O(nlogn)。

 

---

 

 

No.7 堆排序

　　利用数据结构排序，每次取堆顶元素。

　　自己的思路是利用堆插入元素构建堆，接着依次取出堆顶元素，实现排序。

const int Max_N = 10000;

int sz = 0;//堆元素个数 
int heap[Max_N]; //堆 

void swap(int &a, int &b)
{
    int temp = a;
    a = b;
    b = temp;
}

void push( int x )
{
    //自己节点编号
    int i = sz++;
    
    while( i>0 )
    {
        //父亲节点编号 
        int p = (i-1)/2;    
        
        //如果没有大小颠倒则推出
        if( heap[p]<=x )    break;
        
        //把父亲节点数值放下来,将自己下标与之交换
        heap[i] = heap[p];
        i = p; 
    } 
    
    heap[i] = x;
}

int pop()
{
    //最小值 
    int ret = heap[0];
    
    //提到根的数值
    int x = heap[--sz];
    
    //从根开始向下交换
    int i = 0;
    while( i*2+1<sz )
    {
        int a = 2*i+1, b = 2*i+2;
        if( b<sz && heap[b]<heap[a] )    a = b; /*a为孩子较小值下标*/
        
        //如果没有大小颠倒则退出 
        if( heap[a]>=x )    break;
        
        //将儿子提上来 
        heap[i] = heap[a]; 
        i = a; 
    } 
    
    heap[i] = x;
    
    return ret;
}

void heap_sort( int *array, int length )
{
    for( int i=0; i<length; i++ )
    {
        push(array[i]);
    }
    
    for( int i=0; i<length; i++ )
    {
        array[i] = pop();
    }
}

　　这种思路比较耗时，构建堆过程中每一个元素都要从堆尾到堆顶做交换比较。

　　堆排序思路：先将元素加入堆中，再对堆非叶子节点做调整以构建堆，接着依次重复将堆顶下沉到堆尾(与堆尾交换)、重建堆建构，实现排序。

void adjust_heap(int *heap,int i,int length)
{
    int x = heap[i];
    int sz = length;
    
    while( i*2+1<sz )
    {
        int a = i*2+1, b = i*2+2;
        if( b<sz && heap[b]>heap[a] )
        {
            a = b;/*a为孩子较大值下标*/
        }
        
        //如果没有大小颠倒,退出 
        if( heap[a]<=x )    break;
        
        //将孩子提上来
        heap[i] = heap[a];
        i = a; 
    }
    
    heap[i] = x;
}

void heap_sort( int *array, int length )
{
    /*调整构建大顶堆*/
    //第一个非叶子节点是(length-1)/2是因为它是最后一个节点的父亲 
    for( int i=(length-1)/2; i>=0; i-- )
    {/*从第一个非叶子节点从下至上,从右至左调整结构*/
        adjust_heap(array,i,length);
    }
    
    for( int i=length-1; i>0; i-- )
    {
        /*将堆顶元素下沉*/
        swap(array[0],array[i]);
        adjust_heap(array,0,i);//重写调整堆结构 
    }
}

　　对于每个元素其调整操作最多需要O(logn)，共有n个元素，所以堆排序时间复杂度为O(nlogn)。

　　堆排序实际上也是一种选择排序，是一种树形选择排序。普通排序在选择最小值过程中已经与此小值做过了比较，但没有保存，所以每次都要重新比较一遍。

而堆排序利用树形结构保存了中间比较的结果，减少比较次数。

 

---

 

 

No.8 计数排序

　　不同于上述算法的是计数排序不是基于比较的排序算法。算法的思路是用一个数组count[ i ] : 记录在数组中小于等于元素 i 的个数，即元素 i 的升序排名。

void count_sort( int *array, int length )
{
    int max = array[0];
    for( int i=1; i<length; i++ )
    {
        max = max < array[i] ? array[i] : max; 
    }
    
    int *count = new int[max+1]; //count[0,...,max]
    memset(count,0,sizeof(int)*(max+1));
    for( int i=0; i<length; i++ )
    {
        /*记录 array[i] 出现的次数*/
        count[ array[i] ]++;
    }

    for( int i=1; i<=max; i++ )
    {
        /* 记录 i 在array 中的排名*/
        count[i] = count[i-1] + count[i];
    }
    
    int *temp = new int[length];
    for( int i=0; i<length; i++ )
    {
        /* 以array[i]的排名放入临时数组 --因为数组从0开始*/
        temp[ --count[array[i]] ] = array[i];
    }
    
    for( int i=0; i<length; i++ )
    {
        /* 将排序后元素放回原数组 */
        array[i] = temp[i];
    }
    
    delete []count;    delete []temp;
}

　　计数排序采用用空间换时间的方法，使用简单，时间复杂度为O(n+max)。同时具有局限性，比如数值的差距很大，那么有大量的空间没有被使用、因为使用

数组下标计数，所以只适用于整数。

　　计数排序适用于一定范围内的整数排序，且时间复杂度能达到O(n)。

 

---

 

 

No.9 桶排序

　　桶排序可以看作是计数排序的优化，算法将待排数据放入一定大小(数值范围)的有序桶里，再对桶里数据进行排序(可自己选择排序算法)，

最后按序从桶中取出数据。

const int BUCKET_SIZE = 5;//默认用5个桶 

void bucket_sort( int *array, int length )
{
    /*最大/最小值*/
    int max_element,min_element;
    max_element = min_element = array[0];
    for( int i=1; i<length; i++ )
    {
        max_element = max( max_element, array[i] );
        min_element = min( min_element, array[i] );
    }
    
    /*差值*/
    int dif = max_element - min_element;
    /*用二维向量作为桶*/
    vector<int> bucket_list[BUCKET_SIZE];
    
    /*单个桶的区间值*/
    float section = (float)dif/(BUCKET_SIZE);
    
    /*数据入桶*/
    for( int i=0; i<length; i++ )
    {
        /*(当前数-min)/区间-1 -> 桶的下标*/
        int num = (int)((array[i]-min_element)/section)-1;
        if( num<0 )    num = 0;
        bucket_list[num].push_back(array[i]);    
    } 
    
    //桶内排序
    for(int i=0; i<BUCKET_SIZE; i++ )
    {
        sort(bucket_list[i].begin(),bucket_list[i].end());
    }
    
    int index = 0;
    for( int i=0; i<BUCKET_SIZE; i++ )
    {
        for( int j=0; j<bucket_list[i].size(); j++ )
        {
            array[index++] = bucket_list[i][j];
        }
    }
}

　　桶排序是非比较整数排序。

　　最优情况为数据均匀分布于桶中，最坏情况为所有数据在一个桶中，此时的时间复杂度取决于桶内排序算法的选取。所以桶的大小与个数选取十分重要。

　　当所有数值都有唯一对应的桶时，此时无需做桶内排序，可以看作是计数排序。

 

---

 

 

No.10 基数排序

　　非比较整数排序，其思想为按位数逐步划分数据。

const int size = 10;
void radix_sort( int *array, int length )
{    
    int max_element = array[0];
    for( int i=1; i<length; i++ )
    {
        max_element = max( max_element, array[i] );    
    } 
    
    int pow = 1;
    while( true )
    {
        vector<int> bucket_list[size];
        
        for( int i=0; i<length; i++ )
        {
            int radix = (array[i]/pow)%10; /*当前排序位*/
            bucket_list[ radix ].push_back( array[i] ); 
        }
        
        int index = 0;
        for( int i=0; i<size; i++ )
        {
            for( int j=0; j<bucket_list[i].size(); j++ )
            {
                array[index++] = bucket_list[i][j];//放回数据 
            }
        }
        
        pow *= 10;
        if( pow>max_element )    break;
    }
}

　　基数排序可以看作是固定10个桶的桶排序，其排序规则是按照位数，不断的将数据放入桶和从桶中取出数据。

　　可以按位数从左向右排序，也可从右向左。

 

---

 

 

主要参考：https://mp.weixin.qq.com/s/Qf416rfT4pwURpW3aDHuCg