23-js算法入门之四种基础排序

一、冒泡排序

就是两两之间 相互比较 前面的大于后面的则交换 重复这个操作。

  <script>
    function Bubbles(arr) {
      // 1.外层控制排序的轮数
      for (let i = 0; i < arr.length - 1; i++) {
        // 5.设置一个开关
        let flag = true;
        // 2.内层控制每一轮进行的次数
        for (let j = 0; j < arr.length - 1 - i; j++) {
          // 3.比较时，如果前面的大于后面的项，就交换位置
          if (arr[j] > arr[j + 1]) {
            // 6.当这一轮发生了变量交换，说明此轮还未排好序，下一轮继续循环
            flag = false;
            let temp = arr[j];
            arr[j] = arr[j + 1];
            arr[j + 1] = temp;
          }
        }
        // 7.如果这一轮没有发生任何交换，代表数组已排序完毕，后面的就不用执行了，就跳出当前循环
        if (flag === true) {
          break;
        }
      }
      return arr;
    }
    let res = Bubbles([12, 4, 65, 98, 7, 66]);
    console.log(res);
  </script>

1.交换两个变量的几种方法

  <script>
    var a = 10;
    var b = 20;

    //山顶洞人方法
    // var temp = a;
    // a = b;
    // b = temp;
    // console.log(`a:${a},b:${b}`);//a:20,b:10

    // 方法二、运算符
    // var a = a + b;
    // var b = a - b;
    // var a = a - b;
    // console.log(`a:${a},b:${b}`);//a:20,b:10


    // 方法三，es6数据解构
    // [a, b] = [b, a]
    // console.log(`a:${a},b:${b}`);//a:20,b:10

    // 方法四,妙啊
    // =号优先级高于，
    // 先把a赋值给b，在把b给a
    a = [b, b = a][0];
    console.log(`a:${a},b:${b}`);//a:20,b:10
  </script>

二、插入排序

  <script>
    function Insert(arr) {
      // 1.创建一个空数组,用来返回排序号的结果
      let newArr = [];
      // 2.将数组中的第0项添加进去
      newArr.push(arr[0]);
      // 3.第0项不需要比较，从1开始即可
      for (let i = 1; i < arr.length; i++) {
        // 4.从后往前比较
        for (let j = newArr.length - 1; j >= 0; j--) {
          // 5.如果原数组中的项目大于新数组中的
          if (arr[i] > newArr[j]) {
            // 就把新数放在原数的后面
            newArr.splice(j + 1, 0, arr[i]);
            //这一个就不管了，结束
            break;
          }
          // 6.当比到第一项了，就直接放进去
          if (j === 0) {
            newArr.unshift(arr[i]);
          }
        }
      }
      return newArr;
    }

    let res = Insert([1, 5, 9, 77, 66, 22, 45]);
    console.log(res);
  </script>

三、选择排序

就是先假设第一个是最小的，循环遍历，将第一个与所有的比较，当有人比他大，就把那个数的索引值换成最小索引值，再进行比较，这样每一轮都会得到一个最小值，知道length-1轮执行完毕，排序完毕

  <script>
    function Select(arr) {
      // 1.外层循环控制次数
      for (var i = 0; i < arr.length - 1; i++) {
        // 2.假设第i个是最小
        var minIndex = i;
        // 3.j从i+1开始
        for (var j = i + 1; j < arr.length; j++) {
          if (arr[j] < arr[minIndex]) {
            minIndex = j;
          }
        }

        // 当假设的最小值和真实的最小值不配，就进行交换，否者不
        if (minIndex !== i) {
          arr[i] = [arr[minIndex], arr[minIndex] = arr[i]][0];
        }
      }
      return arr;
    }
    var res = Select([2, 6, 20, 1, 7]);
    console.log(res);

  </script>

四、快速排序

原理：找中间项，将小于中间项的放在左，大于放在右，再根据递归重复此操作，知道数组里的项小于等于1为止，最后，左+中+右拼接数组。

  <script>
    function Quick(arr) {
      // 6.当arr索引小于等于1时，结束递归
      if (arr.length <= 1) {
        return arr;
      }
      // 1.找到数组的中间项索引
      let middleIndex = Math.floor(arr.length / 2);
      // 2.找到并提取中间项
      let middle = arr.splice(middleIndex, 1)[0];//从中间索引截取1位组成的数组的第一项就是中间项

      // 3.准备左边的数组和右边的数组
      let left = [],
        right = [];
      // 4.将小于中间项的数push到左边，大于的push到右边
      for (let i = 0; i < arr.length; i++) {
        arr[i] > middle ? right.push(arr[i]) : left.push(arr[i]);
      }
      // 5.递归重复调用quick，最后拼接左中右
      return Quick(left).concat(middle, Quick(right));
    }
    let res = Quick([22, 5, 9, 2]);
    console.log(res);
  </script>