1054. 距离相等的条形码

https://leetcode-cn.com/problems/distant-barcodes/

• 1054. 距离相等的条形码

  • 题目描述

  • 方法1：直接排序

    • 思路

    • 复杂度分析

    • 代码

  • 方法2：堆排序

    • 思路

    • 复杂度分析

    • 代码

  • 方法3

    • 思路

    • 复杂度分析

    • 代码

题目描述

在一个仓库里，有一排条形码，其中第 i 个条形码为 barcodes[i]。

请你重新排列这些条形码，使其中两个相邻的条形码 不能 相等。 你可以返回任何满足该要求的答案，此题保证存在答案。



示例 1：

输入：[1,1,1,2,2,2]
输出：[2,1,2,1,2,1]
示例 2：

输入：[1,1,1,1,2,2,3,3]
输出：[1,3,1,3,2,1,2,1]


提示：

1 <= barcodes.length <= 10000
1 <= barcodes[i] <= 10000

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/distant-barcodes
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

方法1：直接排序

思路

• 统计条形码的出现次数，按出现次数排序

• 取出现次数最多的条形码，填充偶数位(0, 2, 4...)

• 重复上一步骤直到偶数位填充完毕，然后开始填充奇数位(1, 3, 5...)

复杂度分析

• 时间复杂度：$O(NlogN)$，N 是 barcodes 的长度，统计条形码出现次数的时间是 $O(N)$，排序时间是 $O(klogk)$，k 是条形码总数，k 最坏情况下是 N。

• 空间复杂度：$O(N)$，哈希表的空间，最坏的情况是每个条形码都不一样。

代码

JavaScript Code

/**
 * @param {number[]} barcodes
 * @return {number[]}
 */
var rearrangeBarcodes = function (barcodes) {
    const map = {};

    for (let i = 0; i < barcodes.length; i++) {
        const barcode = barcodes[i];
        map[barcode] = (map[barcode] || 0) + 1;
    }

    const list = Object.keys(map).map(b => [Number(b), map[b]]);
    list.sort((a, b) => a[1] - b[1])

    const res = Array(barcodes.length);
    let i = 0;

    while (list.length) {
        let [barcode, count] = list.pop();

        while (count-- > 0) {
            if (i >= barcodes.length) i = 1;

            res[i] = barcode;
            i += 2;
        }
    }
    return res;
};

方法2：堆排序

思路

• 统计条形码的出现次数，建堆

• 从堆中取出现次数最多的条形码，填充偶数位(0, 2, 4...)

• 重复上一步骤直到偶数位填充完毕，然后开始填充奇数位(1, 3, 5...)

复杂度分析

• 时间复杂度：$O(NlogN)$，N 是 barcodes 的长度，统计条形码出现次数的时间是 $O(N)$，每个条形码入堆出堆一次，时间是 $O(NlogN)$。

• 空间复杂度：$O(N)$，哈希表的空间。

代码

JavaScript Code

/**
 * @param {number[]} barcodes
 * @return {number[]}
 */
var rearrangeBarcodes = function (barcodes) {
    const map = {};

    for (let i = 0; i < barcodes.length; i++) {
        const barcode = barcodes[i];
        map[barcode] = (map[barcode] || 0) + 1;
    }

    // 堆的数据结构 [barcode, count]
    const list = Object.keys(map).map(b => [Number(b), map[b]]);
    const heap = new MaxHeap(list, function comparator(inserted, compared) {
        return inserted[1] < compared[1];
    });

    const res = Array(barcodes.length);
    let i = 0;

    while (heap.size() > 0) {
        let [barcode, count] = heap.pop();

        while (count-- > 0) {
            if (i >= barcodes.length) i = 1;

            res[i] = barcode;
            i += 2;
        }
    }
    return res;
};

// **************************************************

class Heap {
    constructor(list = [], comparator) {
        this.list = list;
        this.comparator = comparator;

        this.init();
    }

    init() {
        const size = this.size();
        for (let i = Math.floor(size / 2) - 1; i >= 0; i--) {
            this.heapify(this.list, size, i);
        }
    }

    insert(n) {
        this.list.push(n);
        const size = this.size();
        for (let i = Math.floor(size / 2) - 1; i >= 0; i--) {
            this.heapify(this.list, size, i);
        }
    }

    peek() {
        return this.list[0];
    }

    pop() {
        const last = this.list.pop();
        if (this.size() === 0) return last;
        const returnItem = this.list[0];
        this.list[0] = last;
        this.heapify(this.list, this.size(), 0);
        return returnItem;
    }

    size() {
        return this.list.length;
    }
}

class MaxHeap extends Heap {
    constructor(list, comparator) {
        super(list, comparator);
    }

    heapify(arr, size, i) {
        let largest = i;
        const left = Math.floor(i * 2 + 1);
        const right = Math.floor(i * 2 + 2);

        if (left < size && this.comparator(arr[largest], arr[left]))
            largest = left;
        if (right < size && this.comparator(arr[largest], arr[right]))
            largest = right;

        if (largest !== i) {
            [arr[largest], arr[i]] = [arr[i], arr[largest]];
            this.heapify(arr, size, largest);
        }
    }
}

方法3

思路

• 统计条形码的出现次数，建堆

• 每次从堆中取两个出现次数最多的条形码，将它们加入排列结果中，然后数量分别减一后重新入堆

• 直到堆中元素少于两个

复杂度分析

• 时间复杂度：$O(NlogN)$，N 是 barcodes 的长度，统计条形码出现次数的时间是 $O(N)$，每个条形码入堆出堆一次，时间是 $O(NlogN)$。

• 空间复杂度：$O(N)$，哈希表的空间，最坏的情况是每个条形码都不一样。

代码

JavaScript Code

/**
 * @param {number[]} barcodes
 * @return {number[]}
 */
var rearrangeBarcodes = function (barcodes) {
    const map = {};

    for (let i = 0; i < barcodes.length; i++) {
        const barcode = barcodes[i];
        map[barcode] = (map[barcode] || 0) + 1;
    }

    // 堆的数据结构 [barcode, count]
    const list = Object.keys(map).map(b => [Number(b), map[b]]);
    const heap = new MaxHeap(list, function comparator(inserted, compared) {
        return inserted[1] < compared[1];
    });

    const res = [];
    while (heap.size() > 1) {
        let [b1, cnt1] = heap.pop();
        let [b2, cnt2] = heap.pop();
        res.push(b1, b2)
        if (--cnt1 > 0) heap.insert([b1, cnt1])
        if (--cnt2 > 0) heap.insert([b2, cnt2])
    }
    if (heap.size()) {
        res.push(heap.pop()[0]);
    }
    return res
};

更多题解可以访问：https://github.com/suukii/91-days-algorithm