add: 1046.最后一块石头的重量

Author: suukii

README.md

@@ -247,6 +247,7 @@
 ### 堆
 
 -   [x] [【day-54】215.数组中的第 K 个最大元素](./medium/heap/54.kth-largest-element-in-an-array.md)
+-   [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)

medium/heap/55.last-stone-weight.md

@@ -0,0 +1,148 @@
+# 1046. 最后一块石头的重量
+
+https://leetcode-cn.com/problems/last-stone-weight/
+
+- [1046. 最后一块石头的重量](#1046-最后一块石头的重量)
+  - [题目描述](#题目描述)
+  - [方法1：大顶堆](#方法1大顶堆)
+    - [思路](#思路)
+    - [复杂度分析](#复杂度分析)
+    - [代码](#代码)
+
+## 题目描述
+
+```
+有一堆石头，每块石头的重量都是正整数。
+
+每一回合，从中选出两块 最重的 石头，然后将它们一起粉碎。假设石头的重量分别为 x 和 y，且 x <= y。那么粉碎的可能结果如下：
+
+如果 x == y，那么两块石头都会被完全粉碎；
+如果 x != y，那么重量为 x 的石头将会完全粉碎，而重量为 y 的石头新重量为 y-x。
+最后，最多只会剩下一块石头。返回此石头的重量。如果没有石头剩下，就返回 0。
+
+ 
+
+示例：
+
+输入：[2,7,4,1,8,1]
+输出：1
+解释：
+先选出 7 和 8，得到 1，所以数组转换为 [2,4,1,1,1]，
+再选出 2 和 4，得到 2，所以数组转换为 [2,1,1,1]，
+接着是 2 和 1，得到 1，所以数组转换为 [1,1,1]，
+最后选出 1 和 1，得到 0，最终数组转换为 [1]，这就是最后剩下那块石头的重量。
+ 
+
+提示：
+
+1 <= stones.length <= 30
+1 <= stones[i] <= 1000
+
+来源：力扣（LeetCode）
+链接：https://leetcode-cn.com/problems/last-stone-weight
+著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
+```
+
+## 方法1：大顶堆
+
+### 思路
+
+直接用大顶堆来模拟粉碎石头的游戏。
+
+### 复杂度分析
+
+-   时间复杂度：$O(nlogn)$，n 是数组大小，最坏的情况是，每回合粉碎两块石头之后，都有一颗新的小石头生成。
+-   空间复杂度：$O(n)$，n 是数组大小。
+
+### 代码
+
+JavaScript Code
+
+```js
+/**
+ * @param {number[]} stones
+ * @return {number}
+ */
+var lastStoneWeight = function(stones) {
+    const heap = new MaxHeap(stones);
+
+    while (heap.size() > 1) {
+        const first = heap.pop();
+        const second = heap.pop();
+        if (first > second) heap.insert(first - second)
+    }
+    return heap.size() ? heap.pop() : 0;
+};
+
+// **************************************************
+
+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) {
+        if (typeof comparator != 'function') {
+            comparator = function comparator(inserted, compared) {
+                return inserted < compared;
+            };
+        }
+        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);
+        }
+    }
+}
+```
+
+更多题解可以访问：[https://github.com/suukii/91-days-algorithm](https://github.com/suukii/91-days-algorithm)