JavaScript中的四种常见排序方式

本文将讲述JavaScript中的排序方式，如sort排序、冒泡排序、选择排序、快速排序。尽量以通俗的话术帮助各位对 js 中的排序方式有所了解。

JavaScript中的排序方式

• sort排序
• 冒泡排序
• 选择排序
• 快速排序

sort排序

sort方法接受一个比较函数，用于判断哪个值应该排在前面。默认情况下，sort 方法将数组按升序排列，并且会将数组中的每个元素转换为字符串后再比较大小。例如，数字数组将被按照其字符串形式进行排序，而不是按其数值进行排序。

//为了按数字顺序对数组进行排序，可以传递一个回调函数来指定排序规则。回调函数应该接受两个参数，并返回一个数字

const arr = [25, 10, 30, 5];
arr.sort((a, b) => a - b);
console.log(arr);
// 输出: [5, 10, 25, 30]（按数字比较）

const arr = [25, 10, 30, 5];
arr.sort((a, b) => b - a);
console.log(arr);
// 输出: [30, 25, 10, 5]（按数字比较）

sort 方法可以用于对任何类型的数组进行排序，包括字符串、日期、对象等。如果要对对象数组进行排序，则需要在回调函数中指定要比较的属性。

const arr = [
  {name: "小明", age: 25},
  {name: "小红", age: 18},
  {name: "小刚", age: 23}
];
arr.sort(function(a, b) {
  return a.age - b.age;
});
console.log(arr);
// 输出: [
//   {name: "小红", age: 18},
//   {name: "小刚", age: 23},
//   {name: "小明", age: 25}
// ]

冒泡排序

可以从名字上先进行简单的理解。冒泡，将 最大数 或 最小数 像泡泡一样冒出来。

核心：重复地遍历待排序数组，并比较相邻元素的值
特点：

1. 每一轮次的排序都将有一个 最大数 或 最小数 位置确定（符合冒泡特征）
2. 每一轮次之后，需要进行相邻元素比较的组别都会 -1（依据第一个特点，每轮有一个元素位置被确定）
3. 一共需要执行arr.length - 1的轮次

let arr = [1 ,23 ,45 ,7 ,31 ,28 ,2 , 14]

function BubbleSort(arr){
    let arrLength = arr.length
    // 外层for，决定执行的轮次 arrLength - 1，特点【3】
	for(let i = 0; i < arrLength - 1; i++){
		// 内层for,每轮次都从首个元素开始与相邻元素进行比较
		// i可以看作第i轮次，依据特点【2】，决定每轮次需要比较的次数为 arrLength-1-i
		// 每轮次执行完成后的结果就是特点【1】
        for(let j = 0; j < arrLength - 1 - i; j++){
            if(arr[j] > arr[j + 1]){
                let temp = arr[j]
                arr[j] = arr[j + 1]
                arr[j + 1] = temp
            }
        }
    }
    return arr;
} 

// 冒泡排序时间复杂度为O(n²)

选择排序

快速排序是冒泡排序的进阶版，按照名字可以简单知道该排序方式的特征，选择 ➡ 挑选。在小规模数组遍历排序场景下，效率可能比快速排序等高级排序方法高。

核心： 重复地遍历待排序数组，声明一个记录最大数或最小数下标的属性index，直接将最大数或最小数挑选出来
特点：

1. 每轮次 挑选 出 最大数 或 最小数，使得其与当前 i下标（ i 从 0 开始到 arr.length - 1）的元素交换位置

let arr = [1 ,23 ,45 ,7 ,31 ,28 ,2 , 14]

function selectSort(arr){
    let arrLength = arr.length
    for(let i = 0 ;i < arrLength ;i++){
        let index = i
        // j = i + 1是因为每轮次之后前i位都是位置确定好的元素，直接从i + 1处进行遍历比较
        for(let j = i + 1 ;j < arrLength ;j++){
            if(arr[index] > arr[j]){
            	// 记录下标
                index = j
            }
        }
        let temp = arr[index]
        arr[index] = arr[i]
        arr[i] = temp
    }
    return arr
}

//选择排序时间复杂度为O(n²)

快速排序

快速排序又称快排，是一种基于分治策略的排序算法，在大多数情况下效率要比冒泡、选择排序更高，平均性能好。时间复杂度为O(nlogn)，在最坏情况下能到O(n²)。

过程：采用分治的思想，每轮次或每次递归都以数组中的随机一个数作为基准，将数组以大于或小于基准数作为拆分原则，最后递归或循环操作达到排序目的。

最坏情况：是指每轮次或每次递归选出的随机数恰好为最大数或最小数，导致整个排序过程与快速排序极为相似，时间复杂度就会变为O(n²)。

// 建议使用递归实现快速排序 ⬇
function quickSort(arr) {
	if (arr.length < 2) {
	  return arr;
	}

	// 随机下标取随机数
	const pivotIndex = Math.floor(Math.random() * arr.length);
	const pivot = arr[pivotIndex];
	// 拆分出左侧数组及右侧数组声明
	const left = [];
	const right = [];

	// 以大于或小于随机数作为拆分原则
	for (let i = 0; i < arr.length; i++) {
	  if (i !== pivotIndex) {
	    if (arr[i] < pivot) {
	      left.push(arr[i]);
	    } else {
	      right.push(arr[i]);
	    }
	  }
	}

	// 递归实现整个数组排序
	return [...quickSort(left), pivot, ...quickSort(right)];
}

文章有问题之处还望评论斧正！