JavaScript----数组的排序方式（冒泡，选择，快速）

快速排序

 思路：

        待排序的数组中任意截取(splice:改变原数组)一位,截取相对中间一些的位置 - 中间值

        准备两个数组left/right，用余下的数字分别和中间值进行比较。

       如果比截取的中间值大放到right数组(push)，如果比中间值小放到左边的数组(push)。

        分别对left和right数组进行递归操作，直到数组的每一项长度为1或者0(基点)

        最终利用concat方法将所有的数组连接起来。

        var arr = [12, 3, 3, 3, 3, 569, 78, 0, -56, 1223, 1223, 1223, 11, 16, 13, 1, 12];
        console.log(arr);

        function quickSort(arr) {
            if (Array.isArray(arr)) { //数组
                if (arr.length <= 1) { //长度<=1 输出数组项的值，设为基点
                    return arr;
                } else { //长度>1 进行递归比较
                    var midindex = parseInt(arr.length / 2) //获取中间值的索引
                    var midvalue = arr.splice(midindex, 1)[0]; //改变原数组，截取1位。返回值还是数组。
                    var left = [];
                    var right = [];
                    for (var i = 0; i < arr.length; i++) {
                        if (arr[i] < midvalue) {
                            left.push(arr[i]);
                        } else { //排序
                            right.push(arr[i]);
                        }
                        // else if (arr[i] > midvalue) {//排序+去重
                        //     right.push(arr[i]);
                        // }
                    }
                    return quickSort(left).concat(midvalue, quickSort(right)); //最终的拼接
                }

            } else {
                throw new Error('请输入数组');
            }
        }

        console.log(quickSort(arr));

冒泡排序：

       冒泡排序算法的原理如下：

        比较相邻的元素。 如果第一个比第二个大， 就交换他们两个。

        对每一对相邻元素做同样的工作, 从开始第一对到结尾的最后一对, 在这一点， 最后的元素应该会是最大的数。

        针对所有的元素重复以上的步骤， 除了最后一个。

        持续每次对越来越少的元素重复上面的步骤， 直到没有任何一对数字需要比较。

        function bubbleSort(arr) {
            if (Array.isArray(arr)) { //是数组
                for (var i = 0; i < arr.length - 1; i++) { //控制轮数  -1：12个数字只需要比较11轮。
                    for (var j = 0; j < arr.length - i - 1; j++) { //第i轮，表示已经排序好i个数字。  -1:12个数字两两比较11次。
                        if (arr[j] > arr[j + 1]) { //比较相邻的元素。 如果第一个比第二个大， 就交换他们两个
                            var temp = arr[j];
                            arr[j] = arr[j + 1];
                            arr[j + 1] = temp;
                        }
                    }
                }
                return arr;
            } else { //不是数组
                throw new Error('请输入数组'); //新建错误对象，包含错误信息，抛出错误 throw
            }
        }

        console.log(bubbleSort([12, 3, 569, 78, 0, -56, 1223, 11000, 16, 13, 1, 12]))
        console.log(bubbleSort(arr))

 选择排序：

        选择排序原理是：

        第一次从待排序的数据元素中选出最小（ 或最大） 的一个元素， 存放在序列的起始位置， 然后再从剩余的未排序元素中寻找到最小（ 大） 元素， 然后放到已排序的序列的末尾。 以此类推， 直到全部待排序的数据元素的个数为零。 选择排序是不稳定的排序方法。

       var arr = [12, 3, 569, 78, 0, -56, 1223, -11, 16, 13, -1, 12];
        for (var i = 0; i < arr.length; i++) {
            var minindex = i //依次假设的最小值的索引下标为i 
            var minvalue = arr[minindex]; //假设的最小值
            for (var j = i + 1; j < arr.length; j++) {
                if (arr[j] < minvalue) { //如果当前的数组项的值比最小值还要小，当前的值就是这次最小值
                    minvalue = arr[j]; //当前的值就是最小值
                    minindex = j; //此时的j就是最小值的索引下标。
                }
            }
            //内层的for循环走完一轮，才能得到真正的最小值。才可以进行交换。
            if (minindex !== i) { //代表当前假设的最小值不成立的。找到真正的最小值的索引下标。
                var temp = arr[minindex];
                arr[minindex] = arr[i];
                arr[i] = temp;
            }
        }
        console.log(arr);