排序算法

冒泡排序

一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。

        function bubble(arr) {
            for (var i = 0; i < arr.length - 1; i++) { //外层循环管趟数
                for (var j = 0; j < arr.length - i - 1; j++) { //内层循环管 每一趟的交换次数
                    if (arr[j] > arr[j + 1]) {
                        var temp = arr[j];
                        arr[j] = arr[j + 1];
                        arr[j + 1] = temp;
                    }

                }
            }
            return arr;
        }

选择排序

每一次从待排序的数据元素中选出最小(或最大)的一个元素，存放在序列的起始位置，直到全部待排序的数据元素排完。

        function selection(arr) {
            //遍历数组
            for (var i = 0; i < arr.length; i++) {
                //默认当前最小下标为i,并且记录下来
                var minIndex = i;
                for (var j = i + 1; j < arr.length; j++) {
                    if (arr[j] < arr[minIndex]) {
                        //保存最小数的下标
                        minIndex = j;
                    }
                }
                //若寻找出来的最小数的下标不是当前数的下标，就相互调换位置
                if (minIndex != i) {
                    var temp = arr[minIndex];
                    arr[minIndex] = arr[i];
                    arr[i] = temp;
                }
            }
            return arr;
        }

快速排序

从一组数据中选一个基数，将要排序的数据分成两部分，一部分比基数小，一部分比基数大，再把这两部分同样选择一个基数出来进行排列，依次排列成功。

        function quick(arr) {
            if (arr.length <= 1) {
                return arr;
            }
            //定义左边数组 基数 右边数组
            var left = [],
                mid = arr[0],
                right = [];

            //默认第一个为基数值，即中间值
            for (var i = 1; i < arr.length; i++) { //遍历除第一个外的数组
                arr[i] > mid ? right.push(arr[i]) : left.push(arr[i]);
            }
            return quick(left).concat([mid], quick(right));
        }

插入排序

对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。

        function insertionSort(arr) {
            var len = arr.length;
            var preIndex, current;
            for (var i = 1; i < len; i++) {
                preIndex = i - 1;
                current = arr[i];
                while(preIndex >= 0 && arr[preIndex] > current) {
                    arr[preIndex+1] = arr[preIndex];
                    preIndex--;
                }
                arr[preIndex+1] = current;
            }
            return arr;
        }

希尔排序

先将整个待排序的记录序列分割成为若干子序列分别进行直接插入排序，待整个序列中的记录"基本有序"时，再对全体记录进行依次直接插入排序。

        function shellSort(arr) {
            var len = arr.length,
                temp,
                gap = 1;
            while(gap < len/3) {          //动态定义间隔序列
                gap =gap*3+1;
            }
            for (gap; gap > 0; gap = Math.floor(gap/3)) {
                for (var i = gap; i < len; i++) {
                    temp = arr[i];
                    for (var j = i-gap; j >= 0 && arr[j] > temp; j-=gap) {
                        arr[j+gap] = arr[j];
                    }
                    arr[j+gap] = temp;
                }
            }
            return arr;
        }