JavaScript 数组排序（冒泡排序、选择排序、桶排序、快速排序）

以下均是以实现数组的从小到大排序为例

1、冒泡排序

1. 先遍历数组，让相邻的两个元素进行两两比较 。如果要求小到大排：最大的应该在最后面，如果前面的比后面的大，就要换位置；
2. 数组遍历一遍以后，也就是第一次全部比对结束，最后一个数字就是最大的那个元素；
3. 然后进行第二遍的遍历，还是按照之前的规则，第二大的数字会在倒数第二的位置；
4. 以此类推，直到最后按照从小到大的顺序把数组排好。

         冒泡排序的 比对次数 = 数组长度 - 1

        var arr = [3,5,2,7,9,11,6];
        // 数组一共7个数字，遍历执行总轮数是 6 轮  7 - 1
        for(var k = 0 ; k < arr.length - 1; k ++){
            // 1.两两比对
            // arr.length - 1 - k 已经排序好的数字也没必要再比对了
            for(var i = 0 ; i < arr.length - 1 - k; i++ ){
                // 2.如果前面的大于后面的
                if( arr[i] > arr[i + 1] ){
                    // 3.换位
                    var temp = arr[i];
                    arr[i] = arr[i + 1];
                    arr[i + 1] = temp;
                }
            }
        }
        console.log(arr);

---

2、选择排序

1. 首先假定0是数组中最小的数字的索引。也就是说第一次比对时，假设数组中的第一个元素是最小；
2. 遍历数组，索引为0的元素和后面的所有元素进行比对，找到第一个比它小的元素a，将a的索引替换为0，继续向后比较，找到比a还小的b，将b的索引替换为0…
3. 直到全部比对结束，标记索引为0的就是数组中最小的元素，将他和数组中的第一个元素换位，此时最小的元素在数组的第一位（从小到大排序）；
4. 再来第二次遍历，假定1是最小的数字的索引（因为索引0已经无须比对），也就是当前数组中的第二个元素，继续执行步骤2、3；
5. 以此类推，完成排序。

        var arr = [3,5,2,7,9,11,6];
        for(var k = 0; k < arr.length - 1; k ++){
            // 假定的最小值的索引
            var min   = arr[k];
            var index = k;
            // 求证下标为k的数字是否真的是最小 
            // 和它后面的数字比对，所以i = k+1
            for(var i = k + 1; i < arr.length ; i ++){
                // 找到比它小的元素，记为最小
                if(arr[i] < min){
                    min = arr[i];
                    index = i;
                }
            }
            // 最小值和假定最小值换位
            arr[index] = arr[k];
            arr[k] = min;
        }
        console.log(arr);

---

3、桶排序

1. 根据数组中数字的最大值 建立对应数量的桶
            （遍历时js会自己创建对应数量）；
2. 再根据数组中的每一项数字，把这些数字当做桶的对应索引，给这些索引的桶加水；
3. 遍历一遍所有的桶，从左到右检索把有水的桶的下标列出来即可。

        var arr = [3,2,5,10,7];
        // bocket 承载下标的容器（桶）
        var bocket = [];
        for(var i = 0; i < arr.length ; i++){
            // arr[i]是需要排列的数字
            // console.log(arr[i]);
            // 让arr中的每一个值arr[i]，当做桶里的索引，这些下标是需要加水的
            // 赋值为1的意思是加水：需要随意填一个数据，这个数据是什么不重要
            bocket[arr[i]] = 1; 
        }
        console.log(bocket);
        // 取出索引 先清空原数组，再将排好序的元素push进去
        arr.length = 0;
        // 去遍历这个桶，列出加水的
        for(var attr in bocket){
            // for in之中的取出的attr是字符串，所以要转换
            arr.push(Number(attr));
        }
        console.log(arr);

---

4、快速排序

找中点，分左右。（其实不一定是中点，找一个分界点将数组分为左右两部分就可以）

1. 找到数组的中点，分出它的左右区；
2. 左右元素和中间的比对，比中间小去数组的左边，比中间大去右边；
3. 比对完一轮之后，左边和右边的元素也执行1、2操作。对于左侧的数据，又可以找中点，将该部分数据分成左右两部分，小的去左，大的去右。右侧的数组数据同理；
4. 左右全部排序好后，整个数组的排序也就完成了。

         适合用递归：

        var arr = [2,5,1,7,3];
        function quickSort(arr){
            // 终止条件 数组中只有一项or数组为空时终止递归
            if(arr.length === 1 || arr.length === 0){
                return arr;
            }
            // 找到中间值 以及它的索引
            var mid_index = parseInt(arr.length / 2);
            var mid_num = arr[mid_index];
            // 分左右
            var left  = [];
            var right = [];
            for(var i = 0; i < arr.length ; i++){
                // 中间点不需要和自己比较
                if(i === mid_index){
                    continue;
                }
                // 分配左右
                if(arr[i] > mid_num){
                    right.push(arr[i]);//大的去右边
                }else{
                    left.push(arr[i]);
                }
            }
            // 最终结果是 拼接排好序的left+中间的数据+right
            return quickSort(left).concat([mid_num],quickSort(right));
        }
        var res = quickSort(arr);
        console.log(res);