8.冒泡&选择&插入&快速&归并排序

8.排序：

• 冒泡排序：

  • 原理：重复比较一对相邻元素；
  • 如果元素大小关系不正确，交换这两个数。

      <script>
          function bubbleSort(arr) {
              const len = arr.length;
              for (let i = 0; i < len; i++) {
                  for (let j = 0; j < len - 1; j++) {
                      if (arr[j] > arr[j + 1]) {
                          [arr[j], arr[j + 1]] = [arr[j + 1], arr[j]];
                      }
                  }
              }
              return arr;
          }
          console.log(bubbleSort([3, 6, 2, 4, 1]))
      </script>
  

• 选择排序：

  • 原理：在未排序序列（已排序过的就不用理了）中选择一个最小/最大的，放到前面。
  • 在 [L … N-1] 范围内找出最小项目 X 的位置，
  • 用第 L 项交换X，
  • 将下限 L 增加1并重复步骤1直到 L = N-2。

    <script>
        function selectSort(arr) {
            const len = arr.length;
            // 存放当前区间最小值的索引
            let minIndex;
            for (let i = 0; i < len; i++) {
                minIndex = i;
                // i,j 定义当前区间的上下界,i是左边界,j是右边界
                for (let j = i; j < len; j++) {
                    if (arr[j] < arr[minIndex]) {
                        minIndex = j;
                    }
                }
                    [arr[i], arr[minIndex]] = [arr[minIndex], arr[i]];
            }
            return arr;
        }
        console.log(selectSort([3, 1, 2, 4, 5]));
    </script>

• 插入排序：（类似于抓牌）
  • 通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入；
  • 如果该元素（已排序）大于新元素，将该元素移到下一位置。

插入排序和归并排序

        function InsertSort(arr) {
            const len = arr.length;
            for (let i = 1; i < len; i++) {
                let j = i;
                let temp = arr[j];
                while (j > 0 && arr[j - 1] > temp) {
                    arr[j] = arr[j - 1];
                    j--;
                }
                arr[j] = temp;
            }
            return arr;
        }
        console.log(InsertSort([3, 5, 4, 2, 1]));

• 快速排序：
  • 快速排序：寻找一个基址，使得比基址小的数都在左边,比基址大的数都在右边；
  • 用递归实现，具体实现过程可以打个断点看一下，好理解很多。

    <script>
        // 快速排序:寻找一个基址,使得比基址小的数都在左边,比基址大的数都在右边
        // 用递归实现,具体实现过程可以打个断点看一下,好理解很多
        function quickSort(arr) {
            const len = arr.length;
            if (arr.length < 2) {
                return arr;
            }
            let cur = arr[len - 1];
            // 注意这里
            let left = arr.filter(
                (v) => v < cur
            )
            let right = arr.filter(
                (v) => v > cur
            )
            return [...quickSort(left), cur, ...quickSort(right)]
        }
        console.log(quickSort([3, 2, 6, 1, 5,]));
    </script>

• 归并排序：

  参考：

  • 原理：将每对单个元素（默认情况下，已排序）归并为2个元素的有序数组；
  • 将2个元素的每对有序数组归并成4个元素的有序数组，重复这个过程 ；
  • 最后：归并2个N / 2元素的排序数组（为了简化讨论，我们假设N是偶数）以获得完全排序的N个元素数组。

  可以看一下里面的动画演示，比较直观

      <script>
          function merge(left, right) {
              let res = [];
              let i = 0, j = 0;
              while (i < left.length && j < right.length) {
                  if (left[i] < right[j]) {
                      res.push(left[i]);
                      i++;
                  } else {
                      res.push(right[j]);
                      j++;
                  }
              }
              // 处理末尾元素
              if (i < left.length) {
            		// 返回一个从i开始切割的新的数组,并进行解构  
                  res.push(...left.slice(i));
              } else {
                  res.push(...right.slice(j));
              }
              return res;
          }
          function mergeSort(arr) {
              if (arr.length < 2) {
                  return arr;
              }
              // Math.floor可以理解为向下取整
              const mid = Math.floor(arr.length / 2);
              // slice(begin,end) 包括begin , 不包括 end
              const left = mergeSort(arr.slice(0, mid));
              const right = mergeSort(arr.slice(mid));
              return merge(left, right);
          }
          console.log(mergeSort([3, 6, 2, 4, 1]));
      </script>