經常使用排序算法小結

1. 直接插入排序
   其思想爲：能夠先取出第一個做爲有序區間，遍歷剩下的無序區間，找到待排序元素依次和有序區間比較插入，直到整個數組排序完成，其時間複雜度爲o(n^2),具體實現以下

   #include <stdio.h>
    void insert(int a[], int n) {
        int i, j, x;
        for (i = 1; i < n; i++) {
            x = a[i];
            for (j = i - 1; j > -1 && a[j] > x; a[j+1] = a[j], j--);
            a[j+1] = x;
        }
   
        for (i = 0; i < n; i++) {
            printf("%2d", a[i]);
        }
    } 
   
    int main (void) {
        //直接插入排序，排序思想：遍歷無序區間，找出排序元素
        int a[6] = {3, 5, 4, 6, 2, 7};
        insert(a, 6);   //2, 3, 4, 5, 6, 7
    }

2. 直接選擇排序
   其思想爲：每次從無序區間中找到最小值和無序區間的第一個值進行交換，遍歷整個無序區間，直到無序區間只剩一個值（初始有序區間爲空，無序區間爲整個待排序數組）

   #include <stdio.h>
   
    void select(int a[], int n) {
        int i, j, k, t;
        for (i = 0; i < n-1; i++) {
            k = i;
            for (j = i+1; j < n; j++) {
                if (a[j] < a[k]) {
                    k = j;
                }
            }
            if (k - i) {
                t = a[k];
                a[k] = a[i];
                a[i] = t;
            }
        }
   
        for (i = 0; i < n; i++) {
            printf("%2d", a[i]);
        }
    }
   
    int main (void) {
        int a[6] = {3, 5, 6, 4, 2, 7};
        select(a, 6); //2, 3, 4, 5, 6, 7
    }

3. 冒泡排序
   排序思想：通過n-1趟排序，每一趟找出最小值到冒泡最終的位置，其時間複雜度爲o(n^2), 結束的標誌爲某一趟未通過任何排序，則可認爲排序完成

   #include <stdio.h>
   
    void babel(int a[], int n) {
        int i, j, t, tag = 1;
        for (i = 0; i < n-1 && tag; i++) {
            tag = 0;
            for (j = n-1; j > i; j--) {
                if (a[j] < a[j-1]) {
                    tag = 1;
                    t = a[j];
                    a[j] = a[j-1];
                    a[j-1] = t;
                }
            }
        }
   
        for (i = 0; i < n; i++) {
            printf("%2d", a[i]);
        }
    }
   
    int main(void) {
        int a[6] = {3, 5, 4, 6, 2, 7};
        babel(a, 6);
    }

4. 快速排序
   排序思想：分治，使用遞歸將問題分解。取出第一個元素做爲基準元素（這裏取任何元素均可以，以第一個元素爲例，且爲從小到大排序），從後往前尋找比基準元素小的元素排在左邊，從前日後尋找比基準元素大的元素排在右邊，左遞歸右遞歸，實現元素的排序。具體C代碼以下：

   #include <stdio.h>
   
    int my_sort(int a[], int left, int right) {
        int temp, i, j;
        temp = a[left];
        for (i = left, j = right-1; i < j;) {
            for (; (i < j) && (a[j] >= temp); j--);  //找出比temp小的元素 
            if (i < j) {
                a[i] = a[j];
            } 
            for (; (i < j) && (a[i] < temp); i++);  //找出比temp大的元素 
            if (i < j) {
                a[j] = a[i];
            }
        }
   
        a[i] = temp;
        return i;
    }
   
    void quick(int a[], int left, int right) {
        int mid = -1;
        if (a && left < right) {
            mid = my_sort(a, left, right);
            quick(a, left, mid);    //左邊遞歸 
            quick(a, mid+1, right); //右邊遞歸 
        }
   
    }
   
    int main(void) {
        int a[8] = {5, 6, 2, 3, 4, 1, 7, 8};
        quick(a, 0, 9);
   
        for (int i = 0; i < 8; i++) {
            printf("%2d", a[i]);
        }
        return 0;
    }
   
    //1, 2, 3, 4, 5, 6, 7, 8

   固然，做爲一名前端工程師（不知道夠格不，繼續努力好了），有必要用Javascript語言來展現一下這個應用十分普遍的排序方法，不關乎語言的不一樣，思想上是等同的，只是其中某些方法咱們能夠直接調用。固然，這也是我面試時被問到的，有必要總結一下。

   var quickSort = function (arr) {
        if (arr.length <= 1) {
            return arr;
        }
        var left = [];      //左邊的數組
        var right = [];     //右邊的數組
        var index = Math.floor(arr.length/2);
   
        for (var i = 0, len = arr.length; i < len; i++) {
            if (i - index) {
                if (arr[i] < arr[index]) {
                    left.push(arr[i]);
                } else {
                    right.push(arr[i]);
                }
            }
        }
   
        return quickSort(left).concat(arr[index], quickSort(right));
   
    };
   
    console.log(quickSort([5, 6, 2, 3, 4, 1, 7, 8]));
    //1, 2, 3, 4, 5, 6, 7, 8

5. 歸併排序
   排序思想：依然是分治啦，結合咱們的遞歸。這個排序方法我還回憶了半天，誰叫我很久都沒碰過C語言了勒。感受主要的點在於對數組的左右兩個區間合併過程。

   #include <stdio.h>
   
    //合併排序的過程，拆開看就是將兩個無序數組合併成一個升序序列
    void Result(int a[], int x, int y) {
        int b[200]; //定義的儘可能大吧
        int i, j, k;
        i = x;
        j = (x+y)/2;
        k = 0;
        while(i < (x+y)/2 || j < y) {
            if (j == y || (i < (x+y)/2 && a[i] < a[j])) {
                b[k++] = a[i++];
            } else {
                b[k++] = a[j++];
            }
        }
   
        for (i = x; i < j; i++) {
            a[i] = b[i-x];
        } 
    }
   
    void mergeSort(int a[], int x, int y) {
        if (y - x > 1) {
            mergeSort(a, x, (x+y)/2);
            mergeSort(a, (x+y)/2, y);
            Result(a, x, y);
        }
    }
   
    int main(void) {
        int a[9] = {8, 6, 5, 3, 9, 7, 4, 2, 1};
        mergeSort(a, 0, 9);
        for (int i = 0; i < 9; i++) {
            printf("%2d", a[i]);
        }
        //1, 2, 3, 4, 5, 6, 7, 8, 9
        return 0;
    }

   暫時總結的排序方法就這幾個了，可能本身去畫圖，手動跟蹤運行會理解的更加深入。