排序方法与它们的复杂度

最新推荐文章于 2025-06-12 06:21:30 发布

原创最新推荐文章于 2025-06-12 06:21:30 发布 · 230 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#算法 #排序算法 #快速排序

javascript 专栏收录该内容

5 篇文章

订阅专栏

冒泡排序
原理：从第一个元素开始，把当前元素和下一个索引元素进行比较。如果当前元素大，那么就交换位置，重复操作直到比较到最后一个元素

冒泡排序是稳定排序
冒泡排序空间复杂度O(1)
最优时间复杂度O(n)，当序列已经排序好时，时间复杂度为O(n)
最坏时间复杂度O(n^{2)，当序列是倒序时，时间复杂度为O(n}2)
冒泡排序是一种交换排序

function bubbleSort(arr) {
  if (Array.isArray(arr)) {
    for (var i = arr.length - 1; i > 0; i--) {
      for (var j = 0; j < i; j++) {
        if (arr[j] > arr[j + 1]) {
          [arr[j], arr[j + 1]] = [arr[j + 1], arr[j]];
        }
      }
    }
    return arr;
  }
}

2.插入排序

原理：第一个元素默认是已排序元素，取出下一个元素和当前元素比较，如果当前元素大就交换位置。那么此时第一个元素就是当前的最小数，所以下次取出操作从第三个元素开始，向前对比，重复之前的操作。

直接插入排序属于稳定排序
直接插入排序空间复杂度O(1)
最优时间复杂度O(n)，当待排序的数组已经排序好时，直接插入排序的时间复杂度为O(n)
最坏时间复杂度O(n^{2)，当待排序的数组是倒序时，直接插入排序的时间复杂度为O(n}2)
直接插入排序适用于数量比较少的数组排序

function insertSort(arr) {
  if (Array.isArray(arr)) {
    for (var i = 1; i < arr.length; i++) {
      var preIndex = i - 1;
      var current = arr[i]
      while (preIndex >= 0 && arr[preIndex] > c) {
        arr[preIndex + 1] = arr[preIndex];
        preIndex--;
      }
      arr[preIndex + 1] = current;
    }
    return arr;
  }
}

3.选择排序

原理：遍历数组，设置最小值的索引为 0，如果取出的值比当前最小值小，就替换最小值索引，遍历完成后，将第一个元素和最小值索引上的值交换。如上操作后，第一个元素就是数组中的最小值，下次遍历就可以从索引 1 开始重复上述操作。

直接选择排序
直接选择排序是一种不稳定的排序
时间复杂度为 O(n^2)，当记录占用字节数较多时，直接选择排序通常比直接插入排序的执行速度快些。
空间复杂度为O(1)

function selectSort(arr) {
  if (Array.isArray(arr)) {
    for (var i = 0; i < arr.length - 1; i++) {
      var minIdex = i;
      for (var j = i + 1; j < arr.length; j++) {
        minIdex = arr[j] < arr[minIdex] ? j : minIdex;
      }
      [arr[i], arr[minIdex]] = [arr[minIdex], arr[i]];
    }
    return arr;
  }
}

4.快速排序
原理：在数据集之中，找一个基准点，建立两个数组，分别存储左边和右边的数组，利用递归进行下次比较。

快速排序是不稳定排序
快速排序是一种交换排序
快速排序对序列的操作空间复杂度为O(1)，如果快速排序用递归实现，则递归栈的空间复杂度为O(logn)~O(n)之间。
最佳时间复杂度O(nlogn)
平均时间复杂度O(nlogn)
快速排序是目前基于比较的内部排序中被认为是最好的方法，当待排序的关键字是随机分布时，快速排序的平均时间最短。

function quickSort(arr) {
  if (!Array.isArray(arr)) return;
  if (arr.length <= 1) return arr;
  var left = [], right = [];
  var num = Math.floor(arr.length / 2);
  var numValue = arr.splice(num, 1)[0];
  for (var i = 0; i < arr.length; i++) {
    if (arr[i] > numValue) {
      right.push(arr[i]);
    } else {
      left.push(arr[i]);
    }
  }
  return [...quickSort(left), numValue, ...quickSort(right)]
}

5.希尔排序

原理：
选择一个增量序列 t1，t2，……，tk，其中 ti > tj, tk = 1；
按增量序列个数 k，对序列进行 k 趟排序；
每趟排序，根据对应的增量 ti，将待排序列分割成若干长度为 m 的子序列，分别对各子表进行直接插入排序。仅增量因子为 1 时，整个序列作为一个表来处理，表长度即为整个序列的长度。

希尔排序又叫缩小增量排序，是直接插入排序算法的一种更高效的改进版本
希尔排序属于不稳定排序
希尔排序空间复杂度O(1)
希尔排序的时间复杂度和其增量序列有关系，预计平均时间复杂度O(n^1.3)

function shellSort(arr) {
  var len = arr.length,
    temp,
    gap = 1;
  // 动态定义间隔序列，也可以手动定义，如 gap = 5；
  while (gap < len / 5) {
    gap = gap * 5 + 1;
  }
  for (gap; gap > 0; gap = Math.floor(gap / 5)) {
    for (var i = gap; i < len; i++) {
      temp = arr[i];
      for (var j = i - gap; j >= 0 && arr[j] > temp; j -= gap) {
        arr[j + gap] = arr[j];
      }
      arr[j + gap] = temp;
    }
  }
  return arr;
}

6.归并排序

原理：
（1）把长度为n的输入序列分成两个长度为n/2的子序列；
（2）对这两个子序列分别采用归并排序；
（3）将两个排序好的子序列合并成一个最终的排序序列。

归并排序是建立在归并操作上的一种有效的排序算法,该算法是采用分治法将已有序的子序列合并，最后得到完全有序的序列。
归并排序是稳定排序，速度仅次于快速排序
时间复杂度为O(nlogn)
空间复杂度为O(n) 归并排序需要n空间的临时数组来存储子序列

function mergeSort(arr) {  //采用自上而下的递归方法
  var len = arr.length;
  if (len < 2) {
    return arr;
  }
  var middle = Math.floor(len / 2),
    left = arr.slice(0, middle),
    right = arr.slice(middle);
  return merge(mergeSort(left), mergeSort(right));
}

function merge(left, right) {
  var result = [];
  while (left.length && right.length) {
    // 不断比较left和right数组的第一项，小的取出存入res
    left[0] < right[0] ? result.push(left.shift()) : result.push(right.shift());
  }
  return result.concat(left, right);
}