数组的排序

1、冒泡排序（每一趟找出最大的）

//性能一般
let arr=[1,5,7,9,16,2,4];
//冒泡排序,每一趟找出最大的,总共比较次数为arr.length-1次,每次的比较次数为arr.length-1次，依次递减
let len = arr.length;
for(let k = 0; k < len - 1; k++) {
    for(let m = 0; m < len - k - 1; m++) {
        if(arr[m] > arr[m+1]){
            let val = arr[m];
            arr[m] = arr[m+1];
            arr[m+1] = val;
        }
    }
}
 
console.log(arr)

2、插入排序法（插队排序）

将要排序的数组分成两部分，每次从后面的部分取出索引最小的元素插入到前一部分的适当位置

• 从第一个元素开始，该元素可以认为已经被排序；
• 取出下一个元素，在已经排序的元素序列中从后向前扫描；
• 如果该元素（已排序）大于新元素，将该元素移到下一位置；
• 重复步骤3，直到找到已排序的元素小于或者等于新元素的位置；
• 将新元素插入到该位置后；
• 重复步骤2~5。

function InsertSort(arr) {
  let len = arr.length;
  let preIndex, current;
  for (let i = 1; i < len; i++) {
    preIndex = i - 1;
    current = arr[i];
    while (preIndex >= 0 && current < arr[preIndex]) {
      arr[preIndex + 1] = arr[preIndex];
      preIndex--;
    }
    arr[preIndex + 1] = current;
  }
  return arr;
}
 
 
var arr = [3,5,7,1,4,56,12,78,25,0,9,8,42,37];
InsertSort(arr);

3、快速排序

快速排序对冒泡排序的一种改进

将一个数组的排序问题看成是两个小数组的排序问题，以一个数为基准(中间的数)，比基准小的放
到左边，比基准大的放到右边，而每个小的数组又可以继续看成更小的两个数组，一直递归下去，
直到数组长度大小最大为2。

function quickSort(arr){
   //如果数组长度小于1，没必要排序，直接返回
   if(arr.length<=1) return arr;
   //pivot 基准索引，长度的一半
   let pivotIndex = Math.floor(arr.length/2);//奇数项向下取整
   //找到基准，把基准项从原数组删除
   let pivot = arr.splice(pivotIndex,1)[0];
   //定义左右数组
   let left = [];
   let right = [];
   //把比基准小的放left,大的放right
   arr.forEach(element => {
       if(element<pivot){
           left.push(element)
       }else{
           right.push(element)
       }
   });
   return quickSort(left).concat([pivot],quickSort(right))
}
     
    　
var arr=[4,56,3,67,44,5,66];
console.log(quickSort(arr));//[3, 4, 5, 44, 56, 66, 67]

图片演示：

4、sort排序

//一维数组排序
var arr=[1,5,7,9,16,2,4];
arr.sort(function(a,b){
    return b-a;  //降序排列，return a-b; —>升序排列
})  //括号里不写回调函数，则默认按照字母逐位升序排列，结果为[1,16,2,4,5,7,9]

//对象数组排序
var arr = [
    {name:'syy',age:0},
    {name:'wxy',age:18},
    {name:'slj',age:8},
    {name:'wj',age:20}
];
 
function compare(property){
    return function(a,b){
        var value1 = a[property];
        var value2 = b[property];
        return value1 - value2;//升序,降序为value2 - value1
    }
}
arr.sort(compare('age'))

5、桶排序（桶中出现的数组元素都标记1，然后将桶数组中有1标记的元素一次打印）

//简单, 但是不用,浪费内存
var arr2=[];
for(var i=0;i<arr.length;i++){
    var key=arr[i];
    arr2[key]=1;
}
for(var j in arr2){
    console.log(j);
}

6、选择排序（假如某个位置的值是最小值）

//性能一般
var arr=[1,23,5,8,11,78,45];
let len = arr.length;
for(let k = 0; k < len - 1; k++) {
    for(let m = k + 1; m < len; m++) {
        if(arr[k] > arr[m]){
            let val = arr[m];
            arr[m] = arr[k];
            arr[k] = val;
        }
    }
}
 
console.log(arr)

7、希尔排序（性能最好的排序）

function xier(arr){
    var interval = parseInt(arr.length / 2);  //分组间隔设置
    while(interval > 0){
        for(var i = 0 ; i < arr.length ; i ++){
            var n = i;
            while(arr[n] < arr[n - interval] && n > 0){
                var temp = arr[n];
                arr[n] = arr[n - interval];
                arr[n - interval] = temp;
                n = n - interval;
            }
        }
        interval = parseInt(interval / 2);
    }
    return arr;
}
xier([12,9,38,44,7,98,35,59,49,88,38]);