数组乱序

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

1. Array.prototype.sort()

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

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

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

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

2. Fisher–Yates shuffle 洗牌算法

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

  1. function shuffle(arr) {
  2. let l = arr.length,index,temp
  3. while(l>0) {
  4. index = Math.floor(Math.random() * l)
  5. tmp = arr[l - 1]
  6. arr[l - 1] = arr[index]
  7. arr[index] = temp
  8. l--
  9. }
  10. }


数组排序

1.使用sort()方法

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

2.冒泡排序

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

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

3.选择排序

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

  1. var arr=[11,45,2,32,89,0];
  2. for(var i=0;i<arr.length-1;i++){
  3. var minIndex=i;
  4. for(var j=i+1;j<arr.length;j++){
  5. if(arr[minIndex]>arr[j]){
  6. minIndex=j;
  7. }
  8. }
  9. var temp=arr[i];
  10. arr[i]=arr[minIndex];
  11. arr[minIndex]=temp;
  12. }
  13. document.write(arr);