八大排序算法

關系和復雜度

關系

復雜度

一、冒泡排序

原理

1. 比較相鄰的元素。如果第一個比第二個大，就交換他們兩個。
2. 針對所有的元素重復以上的步驟，除了最后一個。
3. 持續每次對越來越少的元素重復上面的步驟，直到沒有任何一對數字需要比較

代碼

void bubble_sort(int a[], int size){
    for(int i = 0; i < size-1; ++i){
        for(int j = 0; j < size-1-i; ++j){
            if( a[j] > a[j+1] ){
                swap(a, j, j+1);
            }
        }
    }
}

二、選擇排序

原理

選擇排序與冒泡排序有點像，只不過選擇排序每次都是在確定了最小數的下標之后再進行交換，大大減少了交換的次數

代碼

void select_sort(int a[], int size){
    for(int i = 0; i < size-1; ++i){
        int minIndex = i;
        for(int j = i; j < size; ++j){
            if(a[j] < a[minIndex]) minIndex = j; 
        }
        if( minIndex != i){
            int temp = a[i];
            a[i] = a[minIndex];
            a[minIndex] = temp;
        }
    }
}

三、插入排序

原理

將一個記錄插入到已排序的有序表中，從而得到一個新的，記錄數增1的有序表

代碼

void insert_sort(int a[], int size){
    for(int i = 1; i < size-1; ++i){
        int key = a[i];
        int j = i-1;
        while( j >= 0 && a[j] > key ) {
            a[j+1] = a[j];
            j--;
        }
        a[j+1] = key;
    }
}

四、快速排序

原理

通過一趟排序將序列分成左右兩部分，其中左半部分的的值均比右半部分的值小，
然后再分別對左右部分的記錄進行排序，直到整個序列有序。

代碼

int partition(int a[],  int low, int high){
    int key = a[low];
    while( low < high ){
        while(low < high && a[high] >= key) high--;
        a[low] = a[high];
        while(low < high && a[low] <= key) low++;
        a[high] = a[low];
    }
    a[low] = key;
    return low;
}

void quick_sort(int a[], int low, int high){
    if(low >= high) return;
    int keypos = partition(a, low, high);
    quick_sort(a, low, keypos-1);
    quick_sort(a, keypos+1, high);
}

五、堆排序

原理

假設序列有n個元素,先將這n建成大頂堆，然后取堆頂元素，與序列第n個元素交換，然后調整前n-1元素，使其重新成為堆，然后再取堆頂元素，與第n-1個元素交換，再調整前n-2個元素...直至整個序列有序。

代碼

//當列表第一個是以下標0開始，結點下標為i,左孩子則為2*i+1,右孩子下標則為2*i+2,若下標以1開始，左孩子則為2*i,右孩子則為2*i+１
void heapAdjust(int a[], int s, int m){
    int key = a[s];
    for(int j = 2*s + 1; j <= m; j = 2*j + 1 ){
        if(j < m && a[j] <= a[j+1] ) ++j;
        if( a[j] <= key ) break;
        a[s] = a[j];
        s = j;
    }
    a[s] = key;
}
void heap_sort(int a[], int size){
    //初始建堆,從最后一個非葉子節點開始
    for(int i = size/2-1; i >= 0; --i){
        heapAdjust(a, i, size-1);
    }
    //取堆頂，並且調整
    for(int i = size-1; i > 0 ; --i){
        swap(a, 0, i);
        heapAdjust(a, 0, i-1);
    }
    
}

六、希爾排序

原理

希爾排序是插入排序的一種高效率的實現，也叫縮小增量排序。簡單的插入排序中，如果待排序列是正序時，時間復雜度是O(n)，如果序列是基本有序的，使用直接插入排序效率就非常高。希爾排序就利用了這個特點。基本思想是：先將整個待排記錄序列分割成為若干子序列分別進行直接插入排序，待整個序列中的記錄基本有序時再對全體記錄進行一次直接插入排序。

代碼

void shell_insert(int a[], int size, int d){
    for(int i = d; i < size; i++){
        int j = i - d;
        int key = a[i];
        while( j >= 0 && a[j] > temp){
            a[j+d] = a[j];
            j -= d;
        }
        if(j != i-d)
            a[j+d] = key; 
    }
}
void shell_sort(int a[], int size){
    int d = size/2;
    while(d >= 1){
        shell_insert(a, size, d);
        d /= 2;
    }
}

七、歸並排序

原理

1. 把有序表划分成元素個數盡量相等的兩半
2. 把兩半元素分別排序
3. 把兩個有序表合並成一個

代碼

void merge(int a[], int first, int mid, int last){
    int temp[last-first+1];
    int copyIndex = last - first;
    int i = mid, j = last;
    while( i>=first && j >= mid+1 ){
        if(a[i] > a[j]) temp[copyIndex--] = a[i--];
        else temp[copyIndex--] = a[j--];
    }
    while(i >= first ) temp[copyIndex--] = a[i--];
    while(j >= mid+1) temp[copyIndex--] = a[j--];
    for(int k = first; k <= last; ++k){
        a[k] = temp[k-first];
    }
}

void merge_sort(int a[], int first, int last){
    if( first >= last) return;
    int mid = (first + last)/2;
    merge_sort(a, first, mid);
    merge_sort(a, mid+1, last);
    merge(a, first, mid, last);
}

八、計數排序

原理

當待排序的數的值都是在一定的范圍內的整數時，可以用待排序的數作為計數數組的下標，統計每個數的個數，然后依次輸出即可。

代碼

void count_sort(int a[], int size){
    int mx = a[0];
    for(int i = 1; i < size; ++i)
        mx = a[i] > mx ? a[i] :mx;
    int* count = new int[mx+1](); //有() 默認初值為0
    for(int i = 0; i < size; ++i)
        count[a[i]] ++;
    int id = 0;
    for(int i = 0; i <= mx; ++i){
        for(int j = 0; j < count[i]; ++j)
            a[id++] = i;
    }
    delete[] count;
}