add: 1054.距离相等的条形码

Author: suukii

README.md

@@ -250,7 +250,8 @@
 -   [x] [【day-55】1046.最后一块石头的重量](./medium/heap/55.last-stone-weight.md)
 -   [x] [【day-56】23.合并K个升序链表](./medium/heap/56.merge-k-sorted-lists.md)
 -   [x] [【day-57】451.根据字符出现频率排序](./medium/heap/57.sort-characters-by-frequency.md)
--   [x] [【day-58】378. 有序矩阵中第K小的元素](./medium/heap/58.kth-smallest-element-in-a-sorted-matrix.md)
+-   [x] [【day-58】378.有序矩阵中第K小的元素](./medium/heap/58.kth-smallest-element-in-a-sorted-matrix.md)
+-   [x] [【day-59】1054.距离相等的条形码](./medium/heap/59.distant-barcodes.md)
 
 ## 专题篇
 

medium/heap/59.distant-barcodes.md

@@ -0,0 +1,268 @@
+# 1054. 距离相等的条形码
+
+https://leetcode-cn.com/problems/distant-barcodes/
+
+- [1054. 距离相等的条形码](#1054-距离相等的条形码)
+  - [题目描述](#题目描述)
+  - [方法1：直接排序](#方法1直接排序)
+    - [思路](#思路)
+    - [复杂度分析](#复杂度分析)
+    - [代码](#代码)
+  - [方法2：堆排序](#方法2堆排序)
+    - [思路](#思路-1)
+    - [复杂度分析](#复杂度分析-1)
+    - [代码](#代码-1)
+  - [方法3](#方法3)
+    - [思路](#思路-2)
+    - [复杂度分析](#复杂度分析-2)
+    - [代码](#代码-2)
+
+## 题目描述
+
+```
+在一个仓库里，有一排条形码，其中第 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
+
+```js
+/**
+ * @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
+
+```js
+/**
+ * @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
+
+```js
+/**
+ * @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](https://github.com/suukii/91-days-algorithm)