快速排序渐进式学习

一：快速排序思想

现在有一个数组：let nums=[5, 1, 2, 7, 1, 3, 6]，对其进行排序，以下是进行排序的思想：选出一个基准值flag=5，通常我们选择数组的第一个元素作为基准值，然后遍历数组，比flag大的元素放在它右边，比flag小的元素放在它左边，然后就得到了这样一个数组，[3, 1, 2, 1, 5, 7, 6]它的左边元素都比他小，右边元素都比它大，这时候，flag所在的位置就是从小到大排列后的正确位置。

现在我们会很快写出代码：

function quickSort(nums) {
  let leftArr = [];
  let rightArr = [];
  let flag = nums[0];
  for (let i = 1; i < nums.length; i++) {
    if (nums[i] < flag) {
      leftArr.push(nums[i]);
    } else {
      rightArr.push(nums[i]);
    }
  }
  if (leftArr.length > 1) {
    leftArr = quickSort(leftArr, leftArr[0]);
  }
  if (rightArr.length > 1) {
    rightArr = quickSort(rightArr, rightArr[0]);
  }
  return leftArr.concat(flag, rightArr);
}

以上代码看似正确，但是空间复杂度比较高，我们需要创建额外的数组left和right，递归的时候，数组越大，空间消耗越多。于是我们需要追求空间复杂度更低的算法。

二：快速排序准备工作

排序思路还是一样，找个基准值flag，关键在于怎么用最小的时间和空间来通过遍历把flag放到合适的位置，然后再通过递归获取flag左边的排序和flag右边值得排序，不开辟额外的空间就得使用双指针，于是乎就用i，j代表左右两边的指针，他们两个向中间移动：

准备条件

1. 需要有个flag
2. 从右往左，那么nums[j] >= flag 的数不动，如果 nums[j] < flag,就把这个数存储到nums[i]
3. 从左往右，那么nums[i] <= flag 的数不动，如果 nums[i] > flag,就把这个数存储到nums[j]
4. 如果 i >= j, 那么 num[i] = flag

i 0 1 2 3 4 5 6

i=0 j=0 nums= 5 1 2 7 1 3 6 flag=5 nums[0]已经被flag存储，可以存储小的数

i=0 j=5 nums= 3 1 2 7 1 3 6 flag=5 nums[0] = nums[5] = 3, num[5]废弃

i=3 j=5 nums= 3 1 2 7 1 7 6 flag=5 nums[5] = nums[3] = 7, num[3]废弃

i=3 j=4 nums= 3 1 2 1 1 7 6 flag=5 nums[3] = nums[4] = 1, num[4]废弃

i=4 j=4 nums= 3 1 2 1 1 7 6 flag=5 nums[4] = nums[4] = 1, num[4]废弃

i=4 j=4 nums= 3 1 2 1 5 7 6 flag=5 nums[4] = flag

let nums = [5, 1, 2, 7, 1, 3, 6];
function sortFun(numArr) {
  let i = 0;
  let j = nums.length - 1;
  let flag = numArr[0];
  while (i < j) {
    while (i < j && numArr[j] >= flag) {
      j--;
    }
    numArr[i] = numArr[j];
    while (i < j && numArr[i] <= flag) {
      i++;
    }
    numArr[j] = numArr[i];
  }
  numArr[i] = flag;
  return numArr;
}
console.log(sortFun(nums).join("  ")); //3  1  2  1  5  7  6

这样我们就通过双指针的方法，把flag=5放到了放到了数组的中间。然后我们再用递归算出flag左边和右边的数组。

三：递归flag两边数据

let numArr = [5, 1, 2, 0, 0, 3];
function quickSort(nums, left, right) {
  let i = left;
  let j = right;
  let flag = nums[left];
  if (left > right) return;
  while (i < j) {
    while (i < j && nums[j] >= flag) {
      j--;
    }
    //存储小于基准值的数据到i位置
    nums[i] = nums[j];
    // console.log(`i=${i}  j=${j}  nums=  ${nums.join("   ")}  flag=${flag}`);
    while (i < j && nums[i] <= flag) {
      i++;
    }
    //存储大于基准值的数据到j位置
    nums[j] = nums[i];
    // console.log(`i=${i}  j=${j}  nums=  ${nums.join("   ")}  flag=${flag}`);
  }
  nums[i] = flag;
  // console.log(`i=${i}  j=${j}  nums=  ${nums.join("   ")}  flag=${flag}`);
  //左边
  quickSort(nums, left, i - 1);
  //右边
  quickSort(nums, j + 1, right);
  return nums;
}

function sortArray(nums) {
  let res = quickSort(nums, 0, nums.length - 1);
  console.log(res);
}
sortArray(numArr);