算法入门及其C++实现

 https://github.com/yuwei67/Play-with-Algorithms

 

 

 

 

 

 

 

(nlogn)为最优排序算法

 

选择排序

整个数组中，先选出最小元素的位置，将该位置与当前的第一位交换；然后选出剩下数组中，最小元素的位置，将此元素与第二位元素交换；以此类推

 

srand和rand函数使用前，需要包含 stdlib.h和time.h；

 

 插入排序

类似于玩扑克牌时的思想，看后面牌中的每一张牌，然后插入到前方合适的位置

单独看8，不需要排序

6与前面的8比，6小于8，于是6和8互换位置

2先和8比，2小于8，于是互换位置

接下来2和6比，2小于6，于是互换位置，至此前三个数排序结束，后面的排序同理。

 

相较于选择排序，不需要每次遍历所有内容，有提前终止机会，当数组近乎有序时，插入排序效率远高于选择排序，甚至比很多O(nlogn)级别排序算法效率高；

优化插入排序：不贸然交换位置，思路如下

 

 

 

当考察 “2” 时，先把2这个元素复制一个副本，看是否应该放在这个位置，发现2比前面的8小，所以不应该放在这儿，那么将此位置的值赋值为8，然后考察2是不是应该放在原来8的位置；2比这个位置的前一个位置的6要小，所以6放到这个位置；之后看2是不是应该放在原来6的位置，由于是第0个位置，所以2应该放在此处，至此，对2的排序结束。

一次swap是3次赋值，优化后变为多次比较后1次赋值

插入排序，对近乎有序的数组，可以降到O(N)的复杂度

 

归并排序（自顶向下，使用递归）

将数组对半分成2份，左右分别单独排序，本质是递归排序的过程。

时间复杂度比O(N^2)小，但是需要开辟辅助空间

1比2小，所以1放在蓝色指针当前位置，蓝色指针后移，辅助空间中1对应的红色指针后移

之后比较2和4，具体过程同前一步，以此类推。

具体实现：i 和 j 表示当前正在考虑的元素，k 指向这两个元素相比较之后，最终应该放到归并数组中的位置（是下一个需要放置的位置，不是已经排好序的最后一位）

代码示例（未优化，对近乎有序数组性能较差）：

// 将arr[l...mid]和arr[mid+1...r]两部分进行归并
template<typename  T>
void __merge(T arr[], int l, int mid, int r){

    // 经测试,传递aux数组的性能效果并不好
    T aux[r-l+1];
    for( int i = l ; i <= r; i ++ )
        aux[i-l] = arr[i];

    int i = l, j = mid+1;
    for( int k = l ; k <= r; k ++ ){

        if( i > mid )   { arr[k] = aux[j-l]; j ++;}
        else if( j > r ){ arr[k] = aux[i-l]; i ++;}
        else if( aux[i-l] < aux[j-l] ){ arr[k] = aux[i-l]; i ++;}
        else                          { arr[k] = aux[j-l]; j ++;}
    }
}

// 递归使用归并排序,对arr[l...r]的范围进行排序
template<typename T>
void __mergeSort(T arr[], int l, int r){

    if( l >= r )
        return;

    int mid = (l+r)/2;
    __mergeSort(arr, l, mid);
    __mergeSort(arr, mid+1, r);
    __merge(arr, l, mid, r);
}

template<typename T>
void mergeSort(T arr[], int n){

    __mergeSort( arr , 0 , n-1 );
}

 代码优化（第一次）

    

20 // 递归使用归并排序,对arr[l...r]的范围进行排序
21 template<typename T>
22 void __mergeSort(T arr[], int l, int r){
23 
　　　　//对所有条件的优化（小数组使用插入排序，一是因为此时数组近乎有序的概率会比较大，
　　　　//二是因为 N^2 和 NlogN 前是有常数的系数的，对于这个系数，插入排序比归并排序小，所以当N小到一定程度时，插入排序会比归并排序快一些）
　　　　//15这个数是最优的么？
24 //if( l >= r ) 25 // return;
　　　　if( r - l <= 15)
　　　　{
　　　　　　insertionSort(arr,l,r);
　　　　} 26 27 int mid = (l+r)/2; 28  __mergeSort(arr, l, mid);
 29 __mergeSort(arr, mid+1, r);
　　　　//对近乎有序数组的优化
　　　　if(arr[mid] > arr[mid+1]) 30  　　__merge(arr, l, mid, r); 31 }

归并排序（自底向上，使用迭代，统计意义上效率稍弱于递归方式实现）

由于没有使用索引直接获取元素，可以非常好的使用NlogN的时间对链表这样的数据结构进行排序

 

 

 

快速排序

思路：每次从当前数组中选择一个元素，将这个元素想办法挪到排好序的数组中应该在的位置，那么以这个元素为基点，前面的数比他小，后面的数比他大。

　　　　之后对前后两个数组分别继续使用快速排序。

子过程如下：如果当前访问的元素 e 比 v 大，i 指针直接后移；否则调换 i 和 j 后面元素的位置，j 指针后移, i 指针后移；遍历完成后，交换 l 和 j 元素的位置。

// 对arr[l...r]部分进行partition操作
// 返回p,使得arr[l...p-1] < arr[p] ; arr[p+1...r] > arr[p]
template <typename T>
int __partition(T arr[], int l, int r){

    T v = arr[l];

    int j = l; // arr[l+1...j] < v ; arr[j+1...i) > v
    for( int i = l + 1 ; i <= r ; i ++ )
        if( arr[i] < v ){
            j ++;
            swap( arr[j] , arr[i] );
        }

    swap( arr[l] , arr[j]);

    return j;
}

// 对arr[l...r]部分进行快速排序
template <typename T>
void __quickSort(T arr[], int l, int r){

    if( l >= r )
        return;

    int p = __partition(arr, l, r);
    __quickSort(arr, l, p-1 );
    __quickSort(arr, p+1, r);
}

template <typename T>
void quickSort(T arr[], int n){

    __quickSort(arr, 0, n-1);
}

快速排序优化（针对近乎有序数组）

template <typename T>
int _partition(T arr[], int l, int r){

    swap( arr[l] , arr[rand()%(r-l+1)+l] );  5 
    T v = arr[l];
    int j = l;
    for( int i = l + 1 ; i <= r ; i ++ )
        if( arr[i] < v ){
            j ++;
            swap( arr[j] , arr[i] );
        }

    swap( arr[l] , arr[j]);

    return j;
}

template <typename T>
void _quickSort(T arr[], int l, int r){

//    if( l >= r )
//        return;
    if( r - l <= 15 ){
        insertionSort(arr,l,r);
        return;
    }

    int p = _partition(arr, l, r);
    _quickSort(arr, l, p-1 );
    _quickSort(arr, p+1, r);
}

template <typename T>
void quickSort(T arr[], int n){

 srand(time(NULL)); 38     _quickSort(arr, 0, n-1);
}

 快速排序优化（双路快速排序法，针对大量重复元素的数组）

之前小于 v 和大于 v 的数组放于数组的一段，优化后放于数组的两端   

与之前的partition相比较，此方式的最大特点是将等于 v 的元素分散到两侧，不会出现大量相同元素集中在一侧的情况

template <typename T>
int _partition2(T arr[], int l, int r){

    swap( arr[l] , arr[rand()%(r-l+1)+l] );
    T v = arr[l];

    // arr[l+1...i) <= v; arr(j...r] >= v
    int i = l+1, j = r;
    while( true ){ 10         while( i <= r && arr[i] < v ) 11             i ++; 12 
        while( j >= l+1 && arr[j] > v ) 14             j --; 15 
        if( i > j ) 17             break; 18 
 swap( arr[i] , arr[j] ); 20         i ++; 21         j --; 22  } 23 
 swap( arr[l] , arr[j]); 25 
    return j;
}

template <typename T>
void _quickSort(T arr[], int l, int r){

//    if( l >= r )
//        return;
    if( r - l <= 15 ){
        insertionSort(arr,l,r);
        return;
    }

    int p = _partition2(arr, l, r);
    _quickSort(arr, l, p-1 );
    _quickSort(arr, p+1, r);
}

 

三路快速排序

template <typename T>
void __quickSort3Ways(T arr[], int l, int r){

    if( r - l <= 15 ){
        insertionSort(arr,l,r);
        return;
    }

    swap( arr[l], arr[rand()%(r-l+1)+l ] );

    T v = arr[l];

    int lt = l;     // arr[l+1...lt] < v
    int gt = r + 1; // arr[gt...r] > v
    int i = l+1;    // arr[lt+1...i) == v
    while( i < gt ){
        if( arr[i] < v ){
            swap( arr[i], arr[lt+1]);
            i ++;
            lt ++;
        }
        else if( arr[i] > v ){
            swap( arr[i], arr[gt-1]);
            gt --;
        }
        else{ // arr[i] == v
            i ++;
        }
    }

    swap( arr[l] , arr[lt] );

    __quickSort3Ways(arr, l, lt-1);
    __quickSort3Ways(arr, gt, r);
}

template <typename T>
void quickSort3Ways(T arr[], int n){

    srand(time(NULL));
    __quickSort3Ways( arr, 0, n-1);
}