常见算法

数组乱序

当我们想将现有的数组打乱顺序，有两个方法：

1. Array.prototype.sort()

数组的sort()方法
用原地算法对数组的元素进行排序，并返回数组。默认排序顺序是在将元素转换为字符串，然后比较它们的UTF-16代码单元值序列时构建的。

var arr = [1,2,3,4,5,6]
arr.sort(()=> {
  return Math.random() - 0.5
})

sort()方法如果指定了一个函数，那么会按照这个函数的返回值来对数组进行排序：

如果返回值大于0，那么被比较的相邻两个数a和b，a会排到b的后面，
如果返回值等于0，那么a和b的位置不变
如果返回值小于0，那么a会排到b的前面。
但是，用sort()方法不能实现真正意义上的完全乱序（如何将一个 JavaScript 数组打乱顺序？ - Lucas HC的回答 - 知乎），要实现完全乱序，需要用到 Fisher–Yates shuffle 洗牌算法。

2. Fisher–Yates shuffle 洗牌算法

该方法就是每次在数组中随机产生一个位置，依次将数组中的每一项与该次产生的随机位置上的元素交换位置：

function shuffle(arr) {
  let l = arr.length,index,temp
  while(l>0) {
    index = Math.floor(Math.random() * l)
    tmp = arr[l - 1]
    arr[l - 1] = arr[index]
    arr[index] = temp
    l--
  }
}

数组排序

1.使用sort()方法

        var arr=[11,45,2,32,89,0];
        arr.sort(function(a,b){
            return a-b;
        })
        document.write(arr);

2.冒泡排序

概念：数组中相邻元素两两比较，如果第一个元素大于第二元素，交换第一个元素和第二个元素的位置，第一轮比较结束，能确定一个最大值，然后进行第二轮…

        var arr=[11,45,2,32,89,0];
        for(var i=1;i<arr.length;i++){     //第一轮循环表示循环的轮数
                for(var j=0;j<arr.length-i;j++){  //这轮的for循环指的是每次循环的次数
                    if(arr[j]>arr[j+1]){
                        var temp=arr[j];
                        arr[j]=arr[j+1];
                        arr[j+1]=temp;
                    }
                }
             }
            document.write(arr);

3.选择排序

概念：
1.先假定数组中的第一个元素为最小值，对应的索引为minIndex，让该值与剩余元素比较，如果有比该值小的，改变minIndex的指向，让其指向较小的值的索引，让minIndex对应的值和剩下的值进行比较
2.第一轮比较完成之后，我们能确定最小值对应的minIndex，然后让其与第一个元素进行交换
3.假定数组中的第二个元素为最小值，以此类推…

var arr=[11,45,2,32,89,0];
             for(var i=0;i<arr.length-1;i++){
                var minIndex=i;
                for(var j=i+1;j<arr.length;j++){
                    if(arr[minIndex]>arr[j]){
                        minIndex=j;
                    }
                }
                var temp=arr[i];
                arr[i]=arr[minIndex];
                arr[minIndex]=temp;
             }
            document.write(arr);