JS中的数组排序

sort

// sort方法会改变原数组
let arr = [2, 4, 6, 5, 7, 9];
console.log(arr.sort((a, b) => a - b))
// [2, 4, 5, 6, 7, 9]
// 如果数组元素是字符串，则会根据Unicode码进行排序
let brr = ['mango', 'cherry', 'banana', 'apple']
console.log(brr.sort((a, b) => a - b))
// ['mango', 'cherry', 'banana', 'apple']
console.log(brr.sort())
// ['apple', 'banana', 'cherry', 'mango']

1、冒泡排序

描述

• 比较相邻的元素。如果第一个比第二个大，就交换它们两个
• 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对，这样在最后的元素应该会是最大的数
• 针对所有的元素重复以上的步骤，除了最后一个
• 重复步骤1~3，直到排序完成

图示

代码实现

let arr = [1, 3, 4, 2, 9, 6, 5, 8, 7, 10]
function arraySort(arr) {
    // 冒泡排序
    for (let i = 0; i < arr.length; i++) {
        for (let j = 0; j < arr.length - i; j++) {
            if (arr[j] > arr[j + 1]) {
                let temp = arr[j]
                arr[j] = arr[j + 1]
                arr[j + 1] = temp
            }
        }
    }
    return arr
}

let sortArr = arraySort(arr)
console.log(sortArr)
//  [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

2、选择排序

描述

• 首先在未排序序列中找到最小（或最大）元素，存放到排序序列的起始位置
• 然后，再从剩余未排序元素中继续寻找最小（或最大）元素，然后放到已排序序列的末尾
• 以此类推，直到所有元素均排序完毕

图示

代码实现

let arr = [1, 3, 4, 2, 9, 6, 5, 8, 7, 10]
function arraySort(arr) {
    // 选择排序
    for (let i = 0; i < arr.length - 1; i++) {
        let min = i
        for (let j = i + 1; j < arr.length; j++) {
            if (arr[j] < arr[min]) {
                min = j
            }
        }
        let temp = arr[i]
        arr[i] = arr[min]
        arr[min] = temp
    }
    return arr
}

let sortArr = arraySort(arr)
console.log(sortArr)
//  [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

3、插入排序

描述

• 从第一个元素开始，该元素可以认为已经被排序
• 取出下一个元素，在已经排序的元素序列中从后向前扫描, 如果该元素（已排序）大于新元素，将该元素移到下一位置
• 重复上一步骤，直到找到已排序的元素小于或者等于新元素的位置, 将新元素插入到该位置后
• 以此类推，直到所有元素均排序完毕

图示

代码实现

let arr = [1, 3, 4, 2, 9, 6, 5, 8, 7, 10]
function arraySort(arr) {
    // 插入排序
    for (let i = 1; i < arr.length; i++) {
        let temp = arr[i]
        let j = i
        while (j > 0 && arr[j - 1] > temp) {
            arr[j] = arr[j - 1]
            j--
        }
        arr[j] = temp
    }
    return arr
}

let sortArr = arraySort(arr)
console.log(sortArr)
//  [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

4、快速排序

描述

• 从数列中挑出一个元素，称为 “基准”（pivot）
• 重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作
• 递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序

图示

代码实现

let arr = [1, 3, 4, 2, 9, 6, 5, 8, 7, 10];
function arraySort(arr) {
    // 快速排序
    if (arr.length <= 1) {
      return arr;
    }

    let pivotIndex = Math.floor(arr.length / 2); // 选择中间项作为基准
    let pivot = arr[pivotIndex]; // 获取基准值
    let left = []; // 小于基准值的数组
    let right = []; // 大于基准值的数组

    // 遍历数组，将元素分别放入left和right数组中
    for (let i = 0; i < arr.length; i++) {
      if (i === pivotIndex) {
        continue;
      }
      if (arr[i] < pivot) {
        left.push(arr[i]);
      } else {
        right.push(arr[i]);
      }
    }
    return arraySort(left).concat(pivot, arraySort(right));
}

let sortArr = arraySort(arr);
console.log(sortArr);
//  [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

5、归并排序

描述

• 将数组分成两部分，分别对它们进行归并排序，
• 然后将排序好的两部分合并成一个有序的数组
• 将两个排序好的子序列合并成一个最终的排序序列

图示

代码实现

function mergeSort(arr) {
    if (arr.length <= 1) {
        return arr; // 数组长度为0或1时，直接返回
    }

    const middle = Math.floor(arr.length / 2); // 找到数组的中间索引
    const left = arr.slice(0, middle); // 分割出左半部分
    const right = arr.slice(middle); // 分割出右半部分

    // 递归调用mergeSort，并合并结果
    return merge(mergeSort(left), mergeSort(right));
}

function merge(left, right) {
    let result = []; // 初始化一个空数组来存储合并后的结果
    let leftIndex = 0; // 左半部分的索引
    let rightIndex = 0; // 右半部分的索引

    // 比较left和right数组的元素，按照升序合并到result数组中
    while (leftIndex < left.length && rightIndex < right.length) {
        if (left[leftIndex] < right[rightIndex]) {
            result.push(left[leftIndex]);
            leftIndex++;
        } else {
            result.push(right[rightIndex]);
            rightIndex++;
        }
    }

    // 将left数组剩余的元素（如果有）合并到result数组中
    while (leftIndex < left.length) {
        result.push(left[leftIndex]);
        leftIndex++;
    }

    // 将right数组剩余的元素（如果有）合并到result数组中
    while (rightIndex < right.length) {
        result.push(right[rightIndex]);
        rightIndex++;
    }

    return result; // 返回合并后的结果数组
}

let arr = [1, 3, 4, 2, 9, 6, 5, 8, 7, 10];
let sortArr = mergeSort(arr);
console.log(sortArr);
// [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

6、希尔排序

描述

• 它是插入排序的一种更高效的改进版本
• 先将数组进行分组，对每组分别进行插入排序，从而减少数据移动的次数
• 最后逐步缩小分组间隔（也称为增量）直到间隔为1，此时数组已经接近有序
• 最后再进行一次直接的插入排序

图示

代码实现

function shellSort(arr) {
    let n = arr.length;
    let gap = Math.floor(n / 2); // 初始化间隔

    // 不断缩小间隔，直到间隔为0
    while (gap > 0) {
        for (let i = gap; i < n; i++) {
        let temp = arr[i];
        let j = i;

        // 对每组进行插入排序
        while (j >= gap && arr[j - gap] > temp) {
            arr[j] = arr[j - gap];
            j -= gap;
        }

        arr[j] = temp;
        }

        gap = Math.floor(gap / 2); // 缩小间隔
    }

    return arr;
}

let arr = [1, 3, 4, 2, 9, 6, 5, 8, 7, 10];
sortArr = shellSort(arr);
console.log(sortArr);
// [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]