JavaScript数据结构与算法 - 排序算法

Posted 2021-10-22 友人A ㅤ

1. 冒泡排序

冒泡排序比较所有相邻的两个项，如果第一个比第二个大，则交换它们。元素项向上移动至正确的顺序，就好像气泡升至表面一样。但是，从运行时间的角度来看，冒泡排序是最差的一个。

const Compare = {
    LESS_THAN = -1,
    BIGGER_THAN = 1,
    EQUALS = 0
};

function defaultCompare(a, b) {
    if (a === b) {
        return Compare.EQUALS;
    }
    return a < b ? Compare.LESS_THAN : Compare.BIGGER_THAN;
};

function bubbleSort(array, compareFn = defaultCompare) {
    // 存储数组长度
    const { length } = array;
    // 从数组第一位迭代到最后一位，控制了在数组中经过了多少轮排序
    for (let i = 0; i < length; i++) {
        // 从第一位迭代到倒数第二位，从内循环中减去外循环中已跑过的轮数，可以避免内循环中所有不必要的比较
        for (let j = 0; j < length - 1 - i; j++) {
            // 当前项比下一项大，交换顺序
            if (compareFn(array[j], array[j + 1]) === Compare.BIGGER_THAN) {
                swap(array, j, j + 1);
            }
        }
    }
}

function swap(array, a, b) {
    [array[a], array[b]] = [array[b], array[a]];
}

冒泡排序工作过程：

改进后的冒泡排序：如果从内循环减去外循环中已跑过的轮数，就可以避免内循环中所有不必要的比较

时间复杂度： O(n²)

---

2. 选择排序

思路：找到数据结构中的最小值并将其放置在第一位，接着找到第二小的值并将其放在第二位，以此类推。

时间复杂度： O(n²)

---

3. 插入排序

插入排序：每次排一个数组项，以此方式构建最后的排序数组。

1. 假定第一项已经排序了
2. 接着，它和第二项进行比较——第二项是应该待在原位还是插到第一项之前
3. 接着和第三项比较（它是该插入到第一、第二还是第三的位置）
4. 以此类推

function insertionSort(array, compareFn = defaultCompare) {
    const { length } = array;
    let temp;
    // 迭代数组给第i项找到正确的位置
    for (let i = 1; i < length; i++) {
        // 用i的值来初始化一个辅助变量
        let j = i;
        // 将i的值存储在临时变量中
        temp = array[i];
        // 只要j比0大，并且数组中前面的值比待比较的值大
        while (j > 0 && compareFn(array[j - 1], temp) === Compare.BIGGER_THAN) {
            // 将这个值移到当前位置上并减小j
            array[j] = array[j - 1];
            j--;
        }
        array[j] = temp;
    }
    return array;
}

时间复杂度： O(n²)

---

4. 归并排序

归并排序是可以实际使用的排序算法。

归并排序是一种分而治之算法。

算法思想：将原始数组切分成较小的数组，直到每个小数组只有一个位置，接着将小数组归并成较大的数组，直到最后只有一个排序完毕的大数组。

function mergeSort(array, compareFn = defaultCompare) {
    // 算法是递归的，需要一个停止条件：判断数组长度是否为1
    if (array.length > 1) {
        const { length } = array;
        // 找到数组的中间位
        const middle = Math.floor(length / 2);
        // 将数组分为两个小数组
        const left = mergeSort(array.slice(0, middle), compareFn);
        const right = mergeSort(array.slice(middle, length), compareFn);

        array = merge(left, right, compareFn);
    }
    return array;
}
// merge函数，负责合并和排序小数组来产生大数组，直到回到原始数组并已排序完成
function merge(left, right, compareFn) {
    // 声明归并过程要创建的新数组和用来迭代两个数组所需的两个变量
    let i = 0;
    let j = 0;
    const result = [];

    // 比较来自left数组的项是否比来自right数组的项小
    while (i < left.length && j < right.length) {
        // 如果是，将该项从left数组添加至归并结果数组，并递增用于迭代数组的控制变量
        // 如果不是，从right数组添加项并递增用于迭代数组的控制变量
        result.push(compareFn(left[i], right[i]) === Compare.LESS_THAN ? left[i++] : right[j++]);
    }
    // 将left数组所有剩余的项添加到归并数组中，right数组也一样
    return result.concat(i < left.length ? left.slice(i) : right.slice(i));
}

可以看到，算法首先将原始数组分割直至只有一个元素的子数组，然后开始归并。

时间复杂度： O(nlog(n))

---

5. 快速排序

常用算法之一。

快速排序使用分而治之的方法，将原始数组分为较小的数组。

算法思想：

1. 从数组中选择一个值作为主元（pivot），也就是数组中间的那个值
2. 创建两个指针（引用），左边一个指向数组第一个值，右边一个指向数组最后一个值
3. 划分操作：移动左指针直到找到一个比主元大的值，接着，移动右指针直到找到一个比主元小的值，然后交换它们。重复这个过程，直到左指针超过了右指针。这个过程将使得比主元小的值都排在主元之前，而比主元大的值都排在主元之后
4. 算法对划分后的小数组（较主元小的值组成的子数组，以及较主元大的值组成的子数组）重复之前的步骤，直至数组已完全排序

// 声明一个主方法来调用递归函数，传递待排序数组、索引0及其最末的位置作为参数
function quickSort(array, compareFn = defaultCompare) {
    return quick(array, 0, array.length - 1, compareFn);
}

// 创建quick函数
function quick(array, left, right, compareFn) {
    // index能帮助将子数组分离为较小值和较大值数组
    let index;
    // 如果数组长度比1大，就执行partition操作
    if (array.length > 1) {
        index = partition(array, left, right, compareFn);
        // 如果子数组存在较小值的元素，则对该数组重复这个过程
        if (left < index - 1) {
            quick(array, left, index - 1, compareFn);
        }
        // 如果子数组存在较大值的元素，则对该数组重复这个过程
        if (index < right) {
            quick(array, index, right, compareFn);
        }
    }
    return array;
};

// 划分过程
function partition(array, left, right, compareFn) {
    // 选择中间值作为主元
    const pivot = array[Math.floor((right + left) / 2)];
    // 初始化两个指针，为数组第一个元素和最后一个元素
    let i = left;
    let j = right;

    // 两个指针没有相互交错时，就执行划分过程
    while (i <= j) {
        // 移动left指针直到找到一个比主元大的元素
        while (compareFn(array[i], pivot) === Compare.LESS_THAN) {
            i++;
        }
        // 移动right指针直到找到一个比主元小的元素
        while (compareFn(array[j], pivot) === Compare.BIGGER_THAN) {
            j--;
        }
        // 当左指针指向的元素比主元大且右指针指向的元素比主元小，且此时左指针索引没有右指针索引大时
        if (i <= j) {
            // 交换值
            swap(array, i, j);
            // 移动指针，并从外层while处开始重复此过程
            i++;
            j--;
        }
    }
    // 划分操作结束后，返回左指针索引，用来在index = partition(array, left, right, compareFn)处创建子数组
    return i;
}

实现图例：

给定数组[3, 5, 1, 6, 4, 7, 2]，划分操作第一次执行：

对有较小值的子数组执行的划分操作：

有较大值的子数组的划分：

对子数组[2, 3, 5, 4]中的较小子数组[2, 3]继续进行划分：

子数组[2, 3, 5, 4]中的较大子数组[5, 4]也继续进行划分：

最终，较大子数组[6, 7]也会进行划分操作，快速排序算法的操作执行完成。

时间复杂度：O(nlog(n))，性能要比其他O(nlog(n))的好。

---

6. 计数排序

计数排序是分布式排序，是一个整数排序算法。

分布式排序使用已组织好的辅助数据结构（称为桶），然后进行合并，得到排好序的数组。

思路：使用一个用来存储每个元素在原始数组中出现次数的临时数组。在所有元素都计数完成后，临时数组已排好序并可迭代以构建排序后的结果数组。

function countingSort(array) {
    // 如果数组为空或只有一个元素，不需要运行排序算法
    if (array.length < 2) {
        return array;
    }

    // 找到数组中的最大值
    const maxValue = findMaxValue(array);

    // 创建计数数组，从索引0开始直到最大值索引value+1
    const counts = new Array(maxValue + 1);

    // 迭代数组中的每个位置
    array.forEach(element => {
        // 确保递增操作成功。如果counts数组中用来计数某个元素的位置一开始没有用0初始化的话，将其值赋值为0
        if (!counts[element]) {
            counts[element] = 0;
        }
        // 在counts数组中增加元素计数值
        counts[element]++;
    });

    let sortedIndex = 0;
    counts.forEach((count, i) => {
        // 减少计数值直到它为0
        while (count > 0) {
            array[sortedIndex++] = i;
            count--;
        }
    });
    return array;
}

function findMaxValue(array) {
    let max = array[0];
    for (let i = 1; i < array.length; i++) {
        if (array[i] > max) {
            max = array[i];
        }
    }
    return max;
}

时间复杂度：O(n+k)，其中k是临时计数数组的大小。

---

7. 桶排序

桶排序（也被称为箱排序），分布式排序算法。

思路：将元素分为不同的桶（较小的数组），再使用一个简单的排序算法，例如插入排序（用来排序小数组的不错的算法），来对每个桶进行排序。然后，它将所有的桶合并为结果数组。

// 指定需要多少桶来排序数组
function bucketSort(array, bucketSize = 5) {
    if (array.length < 2) {
        return array;
    }
    // 创建桶并将元素分不到不同的桶中
    const buckets = createBuckets(array, bucketSize);
    // 对每个桶执行插入排序算法和将所有的桶合并为排序后的结果数组
    return sortBuckets(buckets);
}

function createBuckets(array, bucketSize) {
    let minValue = array[0];
    let maxValue = array[0];

    // 迭代原数组找到最小值和最大值
    for(let i = 1; i < array.length; i++) {
        if (array[i] < minValue) {
            minValue = array[i];
        } else if (array[i] > maxValue) {
            maxValue = array[i];
        }
    }

    // 计算每个桶中需要分布的元素个数
    const bucketCount = Math.floor((maxValue - minValue) / bucketSize) + 1;
    const buckets = [];
    // 初始化每个桶
    for (let i = 0; i < bucketCount; i++) {
        buckets[i] = [];
    }

    // 迭代数组中的每个元素,计算要将元素放到哪个桶中
    for (let i = 0; i < array.length; i++) {
        const bucketIndex = Math.floor((array[i] - minValue) / bucketSize);
        buckets[bucketIndex].push(array[i]);
    }
    return buckets;
}

function sortBuckets(buckets) {
    // 创建一个用做结果数组的新数组，表示数组不会被修改，会返回一个新数组
    const sortedArray = [];
    // 迭代每个可迭代的桶并应用插入排序
    for (let i = 0; i < buckets.length; i++) {
        if (buckets[i] != null) {
            insertionSort(buckets[i]);
            // 将排好序的桶中的所有元素加入结果数组
            sortedArray.push(...buckets[i]);
        }
    }
    return sortedArray;
}

---

8. 基数排序

基数排序是一个分布式排序算法。

思想：根据数字的有效位或基数将整数分布到桶中。基数是基于数组中值的记数制的。

function radixSort(array, radixBase = 10) {
    if (array.length < 2) {
        return array;
    }
    const minValue = findMinValue(array);
    const maxValue = findMaxValue(array);

    // 从最后一位开始排序所有的数
    let significantDigit = 1;
    // 首先基于最后一位有效位对数字进行排序
    // 在下次迭代时，会基于第二个有效位进行排序，然后第三位，以此类推，直到没有待排序的有效位
    while ((maxValue - minValue) / significantDigit >= 1) {
        array = countingSortForRadix(array, radixBase, significantDigit, minValue);
        significantDigit *= radixBase;
    }
    return array;
}

// 基于有效位（基数）排序
function countingSortForRadix(array, radixBase, significantDigit, minValue) {
    let bucketsIndex = [];
    const buckets = [];
    const aux = [];

    // 基于基数初始化桶（基于十进制就需要十个桶）
    for (let i = 0; i < radixBase; i++) {
        buckets[i] = 0;
    }

    // 基于数组中数的有效位进行计数排序
    for (let i = 0; i < array.length; i++) {
        bucketsIndex = Math.floor(((array[i] - minValue) / significantDigit) % radixBase);
        buckets[bucketsIndex]++;
    }

    // 计算累积结果来得到正确的计数值
    for (let i = 1; i < radixBase; i++) {
        buckets[i] += buckets[i - 1];
    }

    // 计数完成后，要开始将值移回原始数组中
    for (let i = array.length - 1; i >= 0; i--) {
        // 对原始数组中的每个值，再次获取它的有效位并将它的值移到aux数组中
        bucketsIndex = Math.floor(((array[i] - minValue) / significantDigit) % radixBase);
        aux[--buckets[bucketsIndex]] = array[i];
    }

    // 这步可选。将aux数组中的每个值转移到原始数组中
    for (let i = 0; i < array.length; i++) {
        array[i] = aux[i];
    }
    // 除了返回array，也可以直接返回aux数组而不需要赋值它的值
    return array;
}