【算法】排序算法

❤️ Author： 老九
☕️ 个人博客：老九的CSDN博客
🙏 个人名言：不可控之事 乐观面对
😍 系列专栏：

冒泡排序

• 时间复杂度为n的平方((n*(n-1) )/ 2)，空间复杂度为O(1)（因为没有创建过数组，接受的数组不算）

 <script>
  function randomArray(n) {
    var result = []
    for (var i = 0; i < n; i++) {
      //0或上任何数等于本身，浮点数做或运算的时候是取整的
      result.push(Math.random() * n | 0)
    }
    return result
  }
  function isSorted(ary) {
    for (var i = 1; i < ary.length; i++) {
      if (ary[i] < ary[i - 1]) {
        return false
      }
    }
    return true
  }
  function bubbleSort(ary) {
    for (var stop = ary.length - 1; stop >= 1; stop--) {
      var 换过 = false
      for (var i = 0; i < stop; i++) {
        if (ary[i] > ary[i + 1]) {
          换过 = true
          var t = ary[i + 1]
          ary[i + 1] = ary[i]
          ary[i] = t
        }
      } if (!换过) {
        break
      }
    }
    return ary
  }
</script>

选择排序

• 选择其中最小的放在第一个位置，以此类推
• 时间复杂度为n的平方，空间复杂度为1

	<script>
	  function selectSort(ary) {
    //起点最多只需要到倒数第二个位置
    for (var start = 0; start < ary.length - 1; start++) {
      //用来记录无序范围内最小元素的下标
      //先假设起点元素是最小的
      var minIdx = start
      //从起点的下一位开始的最小元素的下标
      for (var i = start + 1; i < ary.length; i++) {
        if (ary[i] < ary[minIdx]) {
          minIdx = i
        }
      }
      //把最小的元素换到当前起点的位置
      var t = ary[start]
      ary[start] = ary[minIdx]
      ary[minIdx] = t
    }
    return ary
  }
	</script>

插入排序

• 时间复杂度n的平方，空间复杂度1
• 依次放在该放的位置上，把数组分为了有序部分和无序部分

<script>
  function insertSort(ary) {
    //i 指向无序部分的第一个
    for (var i = 1; i < ary.length; i++) {
      var value = ary[i]
      for (var j = i - 1; j >= 0; j--) {
        if (ary[j] > value) {
          ary[j + 1] = ary[j]
        } else {
          break
        }
      }
      ary[j + 1] = value
    }
    return ary
  }
</script>

归并排序

• 分成两个数组排序，时间复杂度，n*logn，空间复杂度（n+logn = n）

<script>
  function mergeSort(ary) {
    if (ary.length < 2) {
      return ary
    }
    //拆分
    var mid = Math.floor(ary.length / 2)
    var left = ary.slice(0, mid)
    var right = ary.slice(mid)
    //排序
    mergeSort(left)
    mergeSort(right)
    //合并
    var i = 0
    var j = 0
    var k = 0
    while (i < left.length && j < right.length) {
      if (left[i] < right[j]) {
        ary[k] = left[i]
        k++
        i++
      } else {
        ary[k] = right[j]
        k++
        j++
      }
    }
    while (i < left.length) {
      ary[k] = left[i]
      k++
      i++
    }
    while (j < right.length) {
      ary[k] = right[j]
      k++
      j++
    }
    //返回
    return ary
  }
</script>

快速排序

• 时间复杂度n*logn，空间复杂度是n

/**
 * LeetCode 912: 排序数组
 * @param {number[]} nums 数组
 * @return {number[]} 排序后的数组
 */
const sortArray = function(nums) {
  // 使用内置的快速排序算法进行排序
  const quickSort = (nums, start, end) => {
    if (start >= end) {
      return;
    }
    // 选择基准元素
    const pivot = nums[start];
    let left = start + 1;
    let right = end;

    while (left <= right) {
      // 找到左侧大于等于基准元素的值
      while (left <= right && nums[left] < pivot) {
        left++;
      }
      // 找到右侧小于等于基准元素的值
      while (left <= right && nums[right] > pivot) {
        right--;
      }
      // 交换左侧和右侧的值
      if (left <= right) {
        [nums[left], nums[right]] = [nums[right], nums[left]];
        left++;
        right--;
      }
    }
    // 将基准元素放到正确的位置
    [nums[start], nums[right]] = [nums[right], nums[start]];
    // 递归排序左右两部分
    quickSort(nums, start, right - 1);
    quickSort(nums, right + 1, end);
  };

  // 调用快速排序函数进行排序
  quickSort(nums, 0, nums.length - 1);

  return nums;
};

// 测试用例
const nums = [5, 2, 3, 1];
console.log(sortArray(nums)); // 输出 [1, 2, 3, 5]

————————————————————————
♥♥♥码字不易，大家的支持就是我坚持下去的动力♥♥♥
版权声明：本文为CSDN博主「亚太地区百大最帅面孔第101名」的原创文章