插入排序、冒泡排序、快速排序—— JavaScript

插入排序

<script>
  let arr = [2, 3, 1, 5, 4];
  for (let i = 1; i < arr.length; i++) {
   let t = arr[i];
   let j = i - 1;
   while (arr[j] > t && j >= 0) {
    arr[j + 1] = arr[j];
    j--;
   }
   arr[j + 1] = t;
  }
 </script>

核心思想：
将整个数组分成”已排序部分“和”未排序部分“。然后每次将未排序部分的开头元素插入到已排序部分合适的位置。

实际过程：
（1）将开头元素视作已排序
（2）取出未排序部分的首元素赋给变量 t
（3）在已排序部分，将所有比 t 大的元素向后移一个位置
（4）将 t 插入已排序部分的空位

插入排序是稳定的排序算法。

时间复杂度：O(n^2) 的时间复杂度（输入数据为降序排列的情况），如果输入数据为升序排列，是 O(n) 的时间复杂度。
空间复杂度：O(1)

冒泡排序

<script>
  let arr = [5, 3, 2, 4, 1];
  let length = arr.length;
  for (let i = 0; i < arr.length; i++, length --) {
   for (let j = 0; j < length - 1; j++) {
    if (arr[j] > arr[j + 1]) {
     let t = arr[j];
     arr[j] = arr[j + 1];
     arr[j + 1] = t;
    }
   }
  }
 </script>

核心思想：
每次将相邻两个元素比较，将值更大的元素移到右边。冒泡排序也可以将数组分为“已排序部分”和“未排序部分”。

实际过程：
（1）外层 for 循环控制比较的趟数，内层 for 循环控制每趟比较多少个元素。
（2）在未排序部分中，如果左边的元素更大，就交换位置。
（3）每一趟比较都会将未排序部分的最大值移入已排序部分的首位。
（4）因为（3）的原因，所以每比较一趟未排序部分都会减少一个元素，所以下一次一趟的比较次数可以减一。

冒泡排序是稳定的排序算法。

时间复杂度：O(n^2) 的时间复杂度
空间复杂度：O(1)

快速排序

<script>
  let a = [55, 2, 5, 1, 2, 9, 6];
  quick_sort(0, a.length - 1);
  function quick_sort(left, right) {
   if (left < right) {
    let i = adjust(left, right);
    quick_sort(left, i - 1);
    quick_sort(i + 1, right);
   }
  }
  function adjust(left, right) {
   let i = left;
   let j = right;
   let t = a[left];
   while (i < j) {
    while (i < j && a[j] >= t) {
     j--;
    }
    if (i < j) {
     a[i] = a[j];
     i++;
    }
    while (i < j && a[i] < t) {
     i++;
    }
    if (i < j) {
     a[j] = a[i];
     j--;
    }
   }
   a[i] = t;
   return i;
  }
 </script>

核心思想：
从数组中设定一个基准数，将大于它的元素都移到它的右边，小于它的元素都移到它的左边，然后重复上述操作。

实际过程：
（1）从数组中取出一个基准数
（2）将比基准数大的元素都移到基准数的右边，比它小的都移到左边
（3）然后分区间，重复（1）（2）（3）步。

快速排序是不稳定的排序算法。

时间复杂度：O(nlogn) 的时间复杂度
空间复杂度：O(1)