js sort排序算法详解|极客笔记

js sort排序算法详解

在编程领域中，排序算法是一种非常常见且重要的算法。在JavaScript中，我们经常需要对数组进行排序操作。本文将介绍几种常见的排序算法，并详细讲解它们的实现原理和使用方法。

冒泡排序（Bubble Sort）

冒泡排序是一种简单的排序算法，它重复地遍历要排序的数组，比较相邻的两个元素，并交换它们的位置，直到整个数组有序为止。

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

let arr = [5, 3, 8, 4, 2];
console.log(bubbleSort(arr));

运行结果：[2, 3, 4, 5, 8]

选择排序（Selection Sort）

选择排序也是一种简单直观的排序算法。它在未排序序列中找到最小（大）元素放到已排序序列的末尾，然后继续这个过程，直到整个数组有序。

function selectionSort(arr) {
    let len = arr.length;
    let minIndex, temp;
    for (let i = 0; i < len - 1; i++) {
        minIndex = i;
        for (let j = i + 1; j < len; j++) {
            if (arr[j] < arr[minIndex]) {
                minIndex = j;
            }
        }
        [arr[i], arr[minIndex]] = [arr[minIndex], arr[i]];
    }
    return arr;
}

let arr = [5, 3, 8, 4, 2];
console.log(selectionSort(arr));

运行结果：[2, 3, 4, 5, 8]

插入排序（Insertion Sort）

插入排序是一种简单且高效的排序算法。它通过构建有序序列，在未排序序列中逐个地将元素插入到合适的位置，直到整个数组有序。

function insertionSort(arr) {
    let len = arr.length;
    let preIndex, current;
    for (let i = 1; i < len; i++) {
        preIndex = i - 1;
        current = arr[i];
        while (preIndex >= 0 && arr[preIndex] > current) {
            arr[preIndex + 1] = arr[preIndex];
            preIndex--;
        }
        arr[preIndex + 1] = current;
    }
    return arr;
}

let arr = [5, 3, 8, 4, 2];
console.log(insertionSort(arr));

运行结果：[2, 3, 4, 5, 8]

快速排序（Quick Sort）

快速排序是一种高效的排序算法，它采用分治的策略，将数组分割成两个子数组，分别对子数组进行排序，然后再合并子数组得到排序后的数组。

function quickSort(arr) {
    if (arr.length <= 1) {
        return arr;
    }
    let pivotIndex = Math.floor(arr.length / 2);
    let pivot = arr.splice(pivotIndex, 1)[0];
    let left = [];
    let right = [];
    for (let i = 0; i < arr.length; i++) {
        if (arr[i] < pivot) {
            left.push(arr[i]);
        } else {
            right.push(arr[i]);
        }
    }
    return quickSort(left).concat([pivot], quickSort(right));
}

let arr = [5, 3, 8, 4, 2];
console.log(quickSort(arr));

运行结果：[2, 3, 4, 5, 8]

归并排序（Merge Sort）

归并排序是一种稳定的排序算法，它采用分治的思想，将数组拆分成更小的数组直到无法再拆分为止，然后再将小数组合并成一个有序的数组。

function mergeSort(arr) {
    if (arr.length <= 1) {
        return arr;
    }
    let middle = Math.floor(arr.length / 2);
    let left = arr.slice(0, middle);
    let right = arr.slice(middle);
    return merge(mergeSort(left), mergeSort(right));
}

function merge(left, right) {
    let result = [];
    let leftIndex = 0;
    let rightIndex = 0;
    while (leftIndex < left.length && rightIndex < right.length) {
        if (left[leftIndex] < right[rightIndex]) {
            result.push(left[leftIndex]);
            leftIndex++;
        } else {
            result.push(right[rightIndex]);
            rightIndex++;
        }
    }
    return result.concat(left.slice(leftIndex)).concat(right.slice(rightIndex));
}

let arr = [5, 3, 8, 4, 2];
console.log(mergeSort(arr));

运行结果：[2, 3, 4, 5, 8]

希尔排序（Shell Sort）

希尔排序是一种基于插入排序的排序算法，它以一定的增量进行插入排序，最后再以增量为1进行最后的一次排序，从而实现数组的有序。

function shellSort(arr) {
    let len = arr.length;
    for (let gap = Math.floor(len / 2); gap > 0; gap = Math.floor(gap / 2)) {
        for (let i = gap; i < len; i++) {
            let temp = arr[i];
            let j;
            for (j = i; j >= gap && arr[j - gap] > temp; j -= gap) {
                arr[j] = arr[j - gap];
            }
            arr[j] = temp;
        }
    }
    return arr;
}

let arr = [5, 3, 8, 4, 2];
console.log(shellSort(arr));

运行结果：[2, 3, 4, 5, 8]