js实现冒泡排序，选择排序，插入排序，桶排序和快速排序。

1冒泡排序

// 核心思想：两两比较，交换两者的位置，一次循环得到一个最大（最小）值。
function bubbleSort(arr){
            // 冒泡排序外层循环控制行
            for(var i=0,len=arr.length;i<len-1;i++){
                // 内层循环控制列
                for(var j=0;j<len-1-i;j++){
                    if(arr[j]>arr[j+1]){
                        var temp = arr[j];
                        arr[j] = arr[j+1];
                        arr[j+1] = temp;
                    }
                }

            }
            return arr;
        }

2选择排序

//核心思想：1假定最小值（最大值）位置，2指定最小值和遍历的值进行比较，并记录实际最小值， 3交换实际最小值和指定最小值的位置
        function selectSort(arr){
            for(var i=0,len=arr.length;i<len-1;i++){
                var minIndex = i;
                var minVal = arr[i];
                for(var n=i+1,len=arr.length;n<len;n++){
                    if(arr[n]<minVal){
                        minVal = arr[n];
                        minIndex = n;
                    }
                }
                //指定最小值和实际最小值交换(每次循环只交换一次)                 
                var temp = arr[i];
                arr[i] = minVal;
                arr[minIndex] = temp;
            }
            return arr;
        }

3插入排序

//核心思想：从第二个位置开始记录当前值，依次和前边排好序的比较，大于当前值的位置向后移动一位。最后插入当前值到对应位置。
function insertSort(arr){            
            for(var i=1,len=arr.length;i<len;i++){
            	// 记录前边位置索引和当前值
                var preIndex = i-1;
                var current = arr[i];
                // 当前边索引>=0并且当前值小于前边值，将前边值向后移动一位
                while(preIndex>=0 && current<arr[preIndex]){
                    arr[preIndex+1] = arr[preIndex];
                    preIndex--;
                }
                // 将当前值插入到指定位置
                arr[preIndex+1] = current;

            }
            return arr;
        }

4桶排序

// 核心思想：创建空数组作为桶，将待排序数组遍历到的值作为桶的下标插入。（此方法自动去重了，依赖for in 遍历数组的特性，此方法受限于待排序数组最大值）
function barrelSort(arr){
            var ban = [];//创建一个空桶
            for(var i=0,len=arr.length;i<len;i++){
                //遍历数组中的数，将数值作为桶索引添加数据
                ban[arr[i]] = 'water';
            }
            //用for in 遍历桶，遍历出来的就是原数组的排好序的数值
            arr.length = 0;
            // for in 遍历数组，空值不会被遍历
            for(var index in ban){
                arr.push(parseInt(index));
            }
            return arr;
        }

5快速排序

//核心思想：利用二分法找中间位置的值，分左右存入到新数组，利用递归特性实现
function quickSort(arr){
            //利用二分法，初始化中间位置的索引和值 利用递归特性
            var midIndex = parseInt(arr.length/2);
            var midVal = arr[midIndex];
            var left = [];//初始化左边数组 小于中间位置的值放左侧数组
            var rigth = [];//初始化右边数组 
            // 递归终止条件
            if(arr.length<=1){
                return arr;
            }
            //遍历数组，小于中间位置值的元素放到左侧列表，大于放右侧
            for(var i=0,len=arr.length;i<len;i++){
                if(i == midIndex){  //这里可以控制是否去重，arr[i]==midVal 可以去重
                    continue;//当循环到自身跳出本次循环
                }
                if(arr[i]<midVal){
                    left.push(arr[i]);
                }
                else{
                    rigth.push(arr[i]);
                }                
            }
            // 返回的数组进行拼接
            return quickSort(left).concat([midVal],quickSort(rigth));

        }