排序(1)

冒泡排序

#include<iostream>  
#include<vector>
using namespace std;  
int main(){   
    int num;
    vector<int>a;
    int i = 0;
    while (cin >> num){ 
         a.push_back(num);
         i++;
         if (cin.get() == '\n')   //遇到回車，終止
             break; 
         }
    int e,f,temp；   
    for(e=0;e<i;e++)
        for(f=0;f<i-e-1;f++){
           if(a[f]>a[f+1]){
               temp=a[f];
               a[f]=a[f+1];
               a[f+1]=temp;
           }
        }
    for(int j=0;j<i;j++){  
        cout<<"a["<<j<<"]:"<<a[j]<<endl;  
    }  
}  

時間複雜度O(N^2)

選擇排序

#include<iostream>  
#include<vector>
using namespace std;  
int main()  
{   int num;
    vector<int>arr;
    int n = 0;//n表示輸入個數
    while (cin >> num){ 
         arr.push_back(num);
         n++;
         if(cin.get() == '\n')   //遇到回車，終止
            break;             
    }
    int i,j,min,now;//now表示記錄最小值的位置，min表示最小值  
    for(i=0;i<n-1;i++){
        min=arr[i];
        now=i;
        for(j=i+1;j<n;j++){
           if(min>arr[j]){
              min=arr[j];
              now=j;
           }
        }
        arr[now]=arr[i];
        arr[i]=min;
    }
    for(int k=0;k<n;k++){  
        cout<<"arr["<<k<<"]:"<<arr[k]<<endl;  
    }  
} 

時間複雜度O(N^2)
思路：一列數，選出最小值，放在首位。剩下數，選出最小值，放在次位，依次類推。

插入排序

#include<iostream>  
#include<vector>
using namespace std;  
int i,j,k,insert,now;//now表示記錄插入的位置，insert表示插入值 
void select(vector<int> &arr,int &n)//利用引用實現vector變量數值傳遞
{
    for(i=0;i<n;i++){
        insert=arr[i];
        for(j=0;j<i;j++){  //尋找插入位置
           if(insert<=arr[j]){
              break;
           }
        }
        now=j;
        for(k=i;k>now;k--){  //完成插入過程
            arr[k]=arr[k-1];
        }
        arr[now]=insert;
    } 
}
void out(vector<int> arr,int n)
{
    for(int k=0;k<n;k++){  
        cout<<"arr["<<k<<"]:"<<arr[k]<<endl;  
    }  

}

int main()  
{   int num;
    vector<int>arr;
    int n = 0;//n表示輸入個數
    while (cin >> num){ 
         arr.push_back(num);
         n++;
         if(cin.get() == '\n')   //遇到回車，終止
            break;             
    }
    select(arr,n); 
    out(arr,n);
}  

時間複雜度O(N^2)
1.第1 2數比較，排序。
2.第3 個數依此和2 1比較排序。
3.第4個數依此和3 2 1比較，排序，以此類推。

以上三個經典算法，實現複雜度均爲O(N^2)。下介紹時間複雜度爲O(N*logN)的算法。

歸併排序

看作4個組，組內排序，得到最大長度爲2的有序區間。

看作2個組，組內排序，得到最大長度爲4的有序區間。

最後

#include<iostream>  
#include<vector>
using namespace std;  

void out(vector<int> arr,int n){
    for(int k=0;k<n;k++){  
        cout<<"arr["<<k<<"]:"<<arr[k]<<endl;  
    }  
}
void merge(vector<int> &arr,int low,int mid,int high){
    int i=low; //i是第一段序列的下標
    int j=mid+1; //j是第二段序列的下標
    int k=0; //k是臨時存放合併序列的下標
    int *b=new int[high-low+1]; //b是臨時合併序列
    while(i <= mid && j <= high){// 判斷第一段和第二段取出的數哪個更小，將其存入合併序列，並繼續向下掃描
        if(arr[i] <= arr[j]){
            b[k] = arr[i];
            i++;
            k++;
        } 
        else{
            b[k] = arr[j];
            j++;
            k++;
        }
    }
    while(i<=mid){ //若第一段序列還沒掃描完，將其全部複製到合併序列
        b[k] = arr[i];
        i++;
        k++;
    } 
    while(j<=high){ //若第二段序列還沒掃描完，將其全部複製到合併序列
        b[k]=arr[j];
        j++;
        k++;
    }
    for(k=0,i=low;i<=high;i++,k++){ //將合併序列複製到原始序列中
        arr[i]=b[k];
    }
}

void mergePass(vector<int> &arr,int gap,int n){
    int i=0;    
    for(i=0; i+2*gap-1<n; i=i+2*gap){ //歸併gap長度的兩個相鄰子表
        merge(arr, i, i+gap-1, i+2*gap-1);
    }   
    if (i+gap-1<n){ //餘下兩個子表，後者長度小於gap,若大於n說明就一個子表，不用動
        merge(arr, i, i+gap-1, n-1);
    }
}

void select(vector<int> &arr, int n){
    for(int gap=1;gap<n;gap=2*gap){
        mergePass(arr, gap, n);
    }
}

int main(){
    int num;
    vector<int>arr;
    int n = 0;//n表示輸入個數
    while (cin >> num){ 
         arr.push_back(num);
         n++;
         if(cin.get() == '\n')   //遇到回車，終止
            break;             
    }
    select(arr,n); 
    out(arr,n);
}  

快速排序

一次劃分過程簡述
1.把隨機選中數（3爲例）放到最後（與最後一位交換）

2.設計一個小於等於區間（在最前）

3.下從左到右遍歷所有數，發現比3小的數，同最靠近小於等於區間的數交換，再使區間右擴一個位置。

4.遍歷完成，將3同區間外的數交換，完成劃分

以上爲一次完整劃分過程，它的時間複雜度爲O(N)

#include<iostream>  
#include<vector>
#include<stdlib.h>
using namespace std;  

void out(vector<int> arr,int n){ //數組輸出
    for(int k=0;k<n;k++){  
        cout<<"arr["<<k<<"]:"<<arr[k]<<endl;  
    }  
}

void quicksort(vector<int> &arr, int left,int right){//
    if(left<right){ //表明分的不夠細，需要快速排序
      int now=(rand()%(right-left+1))+left;//生成左右之間的一個隨機數：
                                           //要取得[a,b)的隨機整數，使用(rand()%(b-a))+a; 
                                           //要取得[a,b]的隨機整數，使用(rand()%(b-a+1))+a; 
                                           //要取得(a,b]的隨機整數，使用(rand()%(b-a))+a+1;
      int temp;
      temp=arr[right];
      arr[right]=arr[now];
      arr[now]=temp;           //把選擇節點移植數組末尾
      int k=left;
      for(int i=left;i<right;i++){
          if(arr[i]<arr[right]){  //若發現比選擇節點小的值，放置數組的首部，並移動節點所需放置的位置
             temp=arr[k];
             arr[k]=arr[i];
             arr[i]=temp;
             k++;
          }
      }
      temp=arr[k];
      arr[k]=arr[right];
      arr[right]=temp;           //把選擇節點放在對應的位置，此時其左邊數都比其小，右邊數都比其大。
      quicksort(arr,left,k-1);   //遞歸，處理選擇節點左邊的數組
      quicksort(arr,k+1,right);  //遞歸，處理選擇節點右邊的數組
    }
}

int main(){
    int num;
    vector<int>arr;
    int n = 0;//n表示輸入個數
    while (cin >> num){ 
         arr.push_back(num);
         n++;
         if(cin.get() == '\n')   //遇到回車，終止
            break;             
    }
    quicksort(arr,0,n-1); //快速排序
    out(arr,n);  //輸出數組
}

堆排序
1.建堆

堆頂爲整個排列最大值。
2.把堆頂和堆的最後一個數交換

然後把最大值脫離堆結構

脫離值放到最後，作爲有序部分。

3.下把n-1大小的堆從堆頂進行大根堆調整（這是啥？個人理解是依此把每個子樹的最大值放在根節點的位置），將最大值調至堆頂。再把堆頂和堆的最後一個數交換。遞歸實現，完成排序。

希爾排序
是插入排序的改良算法，插入排序步長爲1，希爾排序步長可調（從大到小）。
下舉例（步長爲3）

6同1（三位前）比較，6 1交換
變爲
1 5 3 6 8 7 2 4
下8同5（三位前）比較，8 5不交換
下7同3（三位前）比較，7 3不交換
下2同6（三位前）比較，2 6交換
1 5 3 2 8 7 6 4
2再同1（三位前）比較，2 1不交換
下4同8（三位前）比較，4 8交換
1 5 3 2 4 7 6 8
4再同5（三位前）比較，4 5交換
1 4 3 2 5 7 6 8

#include<iostream>  
#include<vector>
using namespace std;  

void out(vector<int> arr,int n){ //數組輸出
    for(int k=0;k<n;k++){  
        cout<<"arr["<<k<<"]:"<<arr[k]<<endl;  
    }  
}
void hill(vector<int> &arr, int i,int step){//
    int temp;        
    if(arr[i]<arr[i-step]){
        temp=arr[i];
        arr[i]=arr[i-step];
        arr[i-step]=temp;           
        if(i-2*step>0){   //判斷是否需要向前繼續交換
           hill(arr,i-step,step);    
        }
    }
}
void hillsort(vector<int> &arr, int legth,int step){//
    if(step>=1){
        for(int i=step;i<legth;i++){
            hill(arr,i,step);      
        }   
        step--;   //步長逐級降低
        hillsort(arr,legth,step);   //遞歸希爾排序
    }
}

int main(){
    int num;
    vector<int>arr;
    int n = 0;//n表示輸入個數
    while (cin >> num){ 
         arr.push_back(num);
         n++;
         if(cin.get() == '\n')   //遇到回車，終止
            break;             
    }
    int step=3; //步長的選擇
    hillsort(arr,n,step); //希爾排序
    out(arr,n);  //輸出數組
} 

希爾排序的關鍵：步長選擇。
選擇越優，時間複雜度越低；選擇越劣，時間複雜度趨近於O(N^2)

下介紹時間複雜度爲O(N)的算法，這類算法不是基於比較的排序算法，思想來自桶排序。

計數排序
例子：員工身高排序，建立200個木桶，把人放進去。所有員工進桶後，各個桶依此倒出員工。

#include<iostream>  
#include<vector>
using namespace std;  

void out(vector<int> arr,int n){ //數組輸出
    for(int k=0;k<n;k++){  
        cout<<"arr["<<k<<"]:"<<arr[k]<<endl;  
    }  
}
void countsort(vector<int> &arr, int length){//
    int b[10]={};  //放數用的桶，可用來記錄0~9的數量
    int z=0;
    int temp;
    for(int i=0;i<length;i++){
        b[arr[i]]++;    //把數放在桶裏
    }
    for(int j=0;j<10;j++){  //從桶中倒數
        if(b[j]!=0){
           temp=b[j];
           for(int k=1;k<=temp;k++){
               arr[z]=j;
               z++;
           }
        }
    }
}
int main(){
    int num;
    vector<int>arr;
    int n = 0;//n表示輸入個數
    while (cin >> num){ 
         arr.push_back(num);
         n++;
         if(cin.get() == '\n')   //遇到回車，終止
            break;             
    }
    countsort(arr,n); //計數排序
    out(arr,n);  //輸出數組
} 

基數排序
例：023 014 101 072 084 011
準備0到9，十個桶
根據個位數值選擇進桶

然後依此倒出所有數
101 011 072 023 014 084
再十位倒桶
再倒出
……
最後倒出，完成排序。

#include<iostream>  
#include<vector>
using namespace std;  

void out(vector<int> arr,int n){ //數組輸出
    for(int k=0;k<n;k++){  
        cout<<"arr["<<k<<"]:"<<arr[k]<<endl;  
    }  
}
void basenumbersort(vector<int> &arr, int length){//三次進出桶，可以簡化成一個函數的，這次先分開寫，便於理解
    int b[10][100]={};  //放數用的桶，可用來記錄0~9的數量
    int z=0;
    int temp;
    for(int i=0;i<length;i++){
        int temp1=arr[i]%10;
        b[temp1][0]++;
        b[temp1][b[temp1][0]]=arr[i];   //把數按個位值放在桶裏
    }
    for(int j=0;j<10;j++){  //從桶中倒數
        if(b[j][0]!=0){
           temp=b[j][0];
           for(int k=1;k<=temp;k++){
               arr[z]=b[j][k];
               z++;
           }
        }
    }
    z=0;                           //初始化
    for(int i=0;i<10;i++)
        for(int j=0;j<100;j++){
            b[i][j]=0;
        }

    for(int i=0;i<length;i++){
        int temp1=(arr[i]/10)%10;
        b[temp1][0]++;
        b[temp1][b[temp1][0]]=arr[i];   //把數按十位值放在桶裏
    }
    for(int j=0;j<10;j++){  //從桶中倒數
        if(b[j][0]!=0){
           temp=b[j][0];
           for(int k=1;k<=temp;k++){
               arr[z]=b[j][k];
               z++;
           }
        }
    }
    z=0;//初始化
    for(int i=0;i<10;i++)
        for(int j=0;j<100;j++){
            b[i][j]=0;
        }

    for(int i=0;i<length;i++){
        int temp1=arr[i]/100;
        b[temp1][0]++;
        b[temp1][b[temp1][0]]=arr[i];   //把數按百位值放在桶裏
    }
    for(int j=0;j<10;j++){  //從桶中倒數
        if(b[j][0]!=0){
           temp=b[j][0];
           for(int k=1;k<=temp;k++){
               arr[z]=b[j][k];
               z++;
           }
        }
    }
    z=0;//初始化
    for(int i=0;i<10;i++)
        for(int j=0;j<100;j++){
            b[i][j]=0;
        }
}

int main(){
    int num;
    vector<int>arr;
    int n = 0;//n表示輸入個數
    while (cin >> num){ 
         arr.push_back(num);
         n++;
         if(cin.get() == '\n')   //遇到回車，終止
            break;             
    }
    basenumbersort(arr,n); //計數排序
    out(arr,n);  //輸出數組
}