【算法】十大排序算法-优快云博客

本文链接：https://blog.youkuaiyun.com/Twisted_/article/details/116407054

本文详细介绍了五种经典的排序算法：冒泡排序、快速排序、归并排序、插入排序和选择排序。包括它们的算法描述、时间复杂度分析以及具体的代码实现。通过这些排序算法的学习，可以深入理解数据结构和算法在实际问题中的应用。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

3.1 冒泡排序（Bubble Sort）

3.1.1 算法描述

重复扫描待排序列
比较每一对相邻的元素
- 当元素顺序不正确时进行交换
当没有任何相邻元素能够进行交换时完成排序任务

3.1.2 时间复杂度

最好情况
- 有序排列
- O( n )
平均情况
- 随机排序
- 趋向于O( n^2 )
最差情况
- 元素排序和我们想设置的排序相反
  - 想设置为升序但是数组按照降序
  - 想设置为降序但是数组按照升序
- O( n^2 )

3.1.3 代码块

// 冒泡排序
function bubbleSort(arr) {
    // 复制数组 扩展运算符
    const copyArr = [...arr]
	// 循环遍历数据
    for (let i = 0; i < arr.length; i++) {
        // 设置内循环
        for (let j = i + 1; j < arr.length; j++) {
            if (arr[i] > arr[j]) {
                // 进行数据交换
                var temp = arr[i];
                arr[i] = arr[j];
                arr[j] = temp;
            }
        }
    }
    return arr;
}

const array = [3, 5, 7, -5, -9, 1, 8, 55, 13];
console.log(bubbleSort(array));

3.2 快速排序（Quick Sort）

3.2.1 算法描述

选择一个分界元素将数组拆分为较小的块
分界元素（任意选择一个数组中的元素）
- 小于分界元素
- 等于分界元素
- 大于分界元素
左右两侧的元素继续执行分块步骤
每次划分出来分块之后在需要继续划分时需要重新选取分界元素
最终实现数组的排序

3.2.2 时间复杂度

最好情况
- 元素随机排序
- O( n * logn )
平均情况
- 随机排序
- 趋向于 O( n * logn )
最差情况
- 元素已经排好序
- O( n^2 )

3.2.3 代码块

function quickSort(arr) {
    // 复制数组 扩展运算符
    const copyArr = [...arr];
    // 当数组中只有一个元素时 直接返回元数组
    if (copyArr.length <= 1) {
        return copyArr;
    }

    // 分别创建存放数据的容器
    const smallerArr = [];
    const biggerArr = [];
    // 将数组中的第一个元素设置为分界值
    // shift() 从数组头部取出数据 并放入中间容器
    const index = copyArr.shift();
    const centerArr = [index];

    // 数组中有多个元素 当copyArr的长度不为 0 
    while (copyArr.length) {
        // 取出数组中的第一个数据与分界值比较
        var current = copyArr.shift();

        if (current === index) {
            centerArr.push(current);
        }
        else if (current > index) {
            biggerArr.push(current);
        }
        else {
            smallerArr.push(current);
        }
    }

    // 继续对小于 or 大于 分界值部分执行递归操作
    const smallestArr = quickSort(smallerArr);
    const biggestArr = quickSort(biggerArr);

    // 最终返回小于 等于 大于三个部分的所有数据
    return smallestArr.concat(centerArr, biggestArr);
}

const array = quickSort([-5, -2, -6, 7, 5, 3, 9, 18, 55, 10]);
console.log(array);

3.3 归并排序（Merge Sort）

3.3.1 算法描述

多次拆分数组直到只剩下一个 or 两个元素的数组
- 奇数项数组取中间值划分 Math.floor( arr.length / 2 )
- 偶数项数组 arr.length / 2
对这些数组进行排序然后合并在一起

3.3.2 时间复杂度

3.3.3 代码块

// 归并排序 使用递归
function mergeSort(arr) {
    // 分割数组长度小于 2
    if (arr.length < 2) {
        return arr;
    }
    // 分割长度刚好为 2 
    if (arr.length === 2) {
        return arr[0] > arr[1] ? [arr[1], arr[0]] : arr;
    }
    
    // 数组进行分割
    const middle = Math.floor(arr.length / 2);
    const leftArray = arr.slice(0, middle);
    const rightAray = arr.slice(middle);

    // 递归
    const leftSortedArray = mergeSort(leftArray);
    const rightSortedArray = mergeSort(rightAray);

    // 归并、排序数组
    const mergedArr = [];
    // 设置下标
    let leftArrIndex = 0;
    let rightArrIndex = 0;

    // 当两个数组下标同时大于等于才能跳出循环
    while (leftArrIndex < leftSortedArray.length || rightArrIndex < rightSortedArray.length) {
        // 左右两侧数组大小比较
        if ( leftArrIndex >= leftSortedArray.length || 
            leftSortedArray[leftArrIndex] > rightSortedArray[rightArrIndex]) 
        {    
            mergedArr.push(rightSortedArray[rightArrIndex]);
            // 较小的数组寻找下一位继续比较
            rightArrIndex++;
        }
        else {
            mergedArr.push(leftSortedArray[leftArrIndex]);
            leftArrIndex++;
        }
    }
    return mergedArr;
}
const arr = [5, 1, 2, 3, 6, 9, 8, 4, 7];
console.log(mergeSort(arr));

3.4 插入排序（Insertion Sort）

3.4.1 算法描述

设置变量
- prev 需要与数组中的元素进行大小比较的元素的前一个元素
- current 需要与数组中的元素进行大小比较的元素
循环遍历数组
- for ( i = 1 ; i < array.length ; i++)
- prev = i - 1 ；
- current = array [ i ]
- 当 i 从 1 开始循环的时候方便对比第一个和第二个元素的大小
数组中的元素进行大小对比并进行位置交换
- while(prev >= 0 && array[prev] > current )

3.4.2 代码块

function InsertionSort(array) {
    // 设置变量
    var prev = null;
    var current = null;

    for (var i = 1; i < array.length; i++) {
        prev = i - 1;
        current = array[i];

        // 元素大小判断 并进行位置进行交换
        while (prev >= 0 && array[prev] > current) {
            array[prev + 1] = array[prev];
            prev--;
        }
        array[prev + 1] = current;
    }
    return array;
}
const arrays = [1, 5, 6, 3, 4, 7, 8, 9, 2]
console.log(InsertionSort(arrays));

3.5 选择排序（Selection Sort）

3.5.1 算法描述

n个无序元素需要 n-1 次才能得到有序的数组
[ 0 , n-2 ]
遍历数组找到最小元素并记录下最小元素下标
选择数组中第一个元素为最小元素（min）
进行数据交换

3.5.1 代码块

// 选择排序
function SelectionSort(arrays) {
    var minIndex = null, temp = null;
    for (let i = 0; i < arrays.length - 1; i++) {
        // 存放最小元素的起始位置
        minIndex = i;
        for (let j = i + 1; j < arrays.length; j++) {
            // 查找最小元素并记录位置
            if (arrays[minIndex] > arrays[j]) {
                minIndex = j;
            }
        }
        // 交换数据位置
        temp = arrays[i];
        arrays[i] = arrays[minIndex];
        arrays[minIndex] = temp;
    }
    return arrays;
}

const arrays = [1, 5, 6, 3, 4, 7, 8, 9, 2]
console.log(SelectionSort(arrays));

3.6 希尔排序

3.6.1 算法描述

一种简单的插入排序
设置一个增量序列（步长）
先将整个待排元素序列分割成若干子序列分别进行直接插入排序
然后依次缩减增量再进行排序
待整个序列中的元素基本有序（增量足够小）时，再对全体元素进行一次直接插入排序

3.6.2 代码块

function shellSort(arr) {
    for(var gap = Math.floor(arr.length / 2); gap > 0; gap = Math.floor(gap / 2)) {
        for(var i = gap; i < arr.length; i++) {
            var j = i;
            var current = arr[i];
            while(j - gap >= 0 && current < arr[j - gap]) {
                 arr[j] = arr[j - gap];
                 j = j - gap;
            }
            arr[j] = current;
        }
    }
    return arr;
}
const arr = [5, 1, 2, 3, 6, 9, 8, 4, 7];
console.log(shellSort(arr));