经常使用排序算法小结

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;
    }

   暂时总结的排序方法就这几个了，可能本身去画图，手动跟踪运行会理解的更加深入。