选择排序，冒泡排序，桶排序和快速排序

排序方式之选择排序

这里我们用从小到大排序举例
第一：假定第一个是最小的项
第二：用第一个不断跟后面的项依次对比，如果有更小的项，记录这个最小的项和下标
第三：完成一次循环后，将第一个项与这个项交换位置。
第四：第二次循环从第二项开始，以此类推，循环至完成倒数第二项的判断。
代码实现：

var arr = [11,2,32,4,54,6,3];
 for(var k=0;k<arr.length-1;k++){
            var min   = arr[k];
            var index = k;
            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)

排序方式之冒泡排序

冒泡排序也是一种选择排序法，只是在查找最小值采用了不同方法。同样以从小到大排序为例
第一：比较第一个和第二个的大小，如果第二个比第一个小，交换位置；
第二：依次迭代，这样就会把未排序的最小元素放到它正确的位置；
第三：直到将倒数第二个元素排到正确的位置；

	for(k = 0;k<arr.length - 1;k++){
            for(i=0;i<arr.length - 1-k; i++){
                if(arr[i]>arr[i+1]){
                    var team = arr[i];
                    arr[i] = arr[i+1];
                    arr[i+1] = team;
        }
        }
        }
        console.log(arr);

改进：
如果这个列表已经是有序的，以上排序还要继续循环比较，这是没有意义的。我们可以在进入循环之前，设置一个布尔值变量为false，如果在循环中发生了交换操作，把布尔值变量改为true。如果这次循环结束时，布尔变量仍然是false，证明这个列表是有序的，整个过程不必再继续；

var bool = false;
        for(k = 0;k<arr.length - 1;k++){
            for(i=0;i<arr.length - 1-k; i++){
                if(arr[i]>arr[i+1]){
                    var team = arr[i];
                    arr[i] = arr[i+1];
                    arr[i+1] = team;
                    bool = true;
        }
        }
        if( bool ===false){
            break;
        }
        }

排序方式之桶排序

桶排序是一种极端的排序方式，内存占用较多。我们都知道数组下标是有序的，无论放入什么内容，数组下标都是不会乱的
第一：需要一个新数组，用旧数组的项作为新数组的下标
第二：随意为新数组的每项赋值
第三：清空原数组，取出新数组的下标挨个增加到原数组；

        var arr = [3,2,5,7,10]
        var bocket = [];
        for(var i = 0 ;  i < arr.length ; i ++){
            bocket[arr[i]] = 1;
        }
        arr.length = 0;
        // 用for in 取出更好，比for 循环节省执行次数;
        for(var attr in bocket){
            // 因为 for in 之中取出的 attr 是字符串,那么我们需要进行一波转换;
            arr.push(Number(attr));
        }
        console.log(arr);

排序方式之快速排序

这中策略的基础是递归，将数组一分为二，然后对两个小数组继续同样的方法，直至不需要再分，使用了递归，数字较多的时候对性能需求较高；
第一：找重点，分左右。找到中点下标以及这个值
第二：建立两个空数组，起名左右。比中点值小的放在左边数组，比中点值大的放在右边数组；
第三：持续往下分，直至数组中只有一项或者数组为空，终止递归执行

 // 找中点 分左右!;
        var arr = [2,5,1,3,7,4];
        function quickSort( arr ){
            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]);
                }
            } 
            //注意：concat第一个参数必须转换成数组; => [mid_num]
            return quickSort(left).concat( [mid_num] , quickSort(right) );
        }
        var res = quickSort( arr )
        console.log(res);