feat: add solutions to lc/lcof2 problems: Kth Largest Element in a

Stream

Author: yanglbme

.github/workflows/starcharts.yml

@@ -2,7 +2,7 @@ name: Starcharts
 
 on:
   schedule:
-    - cron: "0 0 * * 0"
+    - cron: "0 0/12 * * *"
   workflow_dispatch:
 
 jobs:

lcof2/剑指 Offer II 059. 数据流的第 K 大数值/README.md

@@ -55,22 +55,171 @@ kthLargest.add(4);   // return 8
 
 <!-- 这里可写通用的实现逻辑 -->
 
+小根堆存放最大的 k 个元素，那么堆顶就是第 k 大的元素。
+
 <!-- tabs:start -->
 
 ### **Python3**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```python
+class KthLargest:
+
+    def __init__(self, k: int, nums: List[int]):
+        self.q = []
+        self.size = k
+        for num in nums:
+            self.add(num)
+
+    def add(self, val: int) -> int:
+        heapq.heappush(self.q, val)
+        if len(self.q) > self.size:
+            heapq.heappop(self.q)
+        return self.q[0]
+
 
+# Your KthLargest object will be instantiated and called as such:
+# obj = KthLargest(k, nums)
+# param_1 = obj.add(val)
 ```
 
 ### **Java**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```java
+class KthLargest {
+    private PriorityQueue<Integer> q;
+    private int size;
+
+    public KthLargest(int k, int[] nums) {
+        q = new PriorityQueue<>(k);
+        size = k;
+        for (int num : nums) {
+            add(num);
+        }
+    }
+
+    public int add(int val) {
+        q.offer(val);
+        if (q.size() > size) {
+            q.poll();
+        }
+        return q.peek();
+    }
+}
+
+/**
+ * Your KthLargest object will be instantiated and called as such:
+ * KthLargest obj = new KthLargest(k, nums);
+ * int param_1 = obj.add(val);
+ */
+```
+
+### **C++**
+
+```cpp
+class KthLargest {
+public:
+    priority_queue<int, vector<int>, greater<int>> q;
+    int size;
+
+    KthLargest(int k, vector<int>& nums) {
+        size = k;
+        for (int num : nums) add(num);
+    }
+
+    int add(int val) {
+        q.push(val);
+        if (q.size() > size) q.pop();
+        return q.top();
+    }
+};
+
+/**
+ * Your KthLargest object will be instantiated and called as such:
+ * KthLargest* obj = new KthLargest(k, nums);
+ * int param_1 = obj->add(val);
+ */
+```
 
+### **Go**
+
+```go
+type KthLargest struct {
+	h *IntHeap
+	k int
+}
+
+func Constructor(k int, nums []int) KthLargest {
+	h := &IntHeap{}
+	heap.Init(h)
+	for _, v := range nums {
+		heap.Push(h, v)
+	}
+
+	for h.Len() > k {
+		heap.Pop(h)
+	}
+
+	return KthLargest{
+		h: h,
+		k: k,
+	}
+}
+
+func (this *KthLargest) Add(val int) int {
+	heap.Push(this.h, val)
+	for this.h.Len() > this.k {
+		heap.Pop(this.h)
+	}
+
+	return this.h.Top()
+}
+
+func connectSticks(sticks []int) int {
+	h := IntHeap(sticks)
+	heap.Init(&h)
+	res := 0
+	for h.Len() > 1 {
+		val := heap.Pop(&h).(int)
+		val += heap.Pop(&h).(int)
+		res += val
+		heap.Push(&h, val)
+	}
+	return res
+}
+
+type IntHeap []int
+
+func (h IntHeap) Len() int           { return len(h) }
+func (h IntHeap) Less(i, j int) bool { return h[i] < h[j] }
+func (h IntHeap) Swap(i, j int)      { h[i], h[j] = h[j], h[i] }
+func (h *IntHeap) Push(x interface{}) {
+	*h = append(*h, x.(int))
+}
+func (h *IntHeap) Pop() interface{} {
+	old := *h
+	n := len(old)
+	x := old[n-1]
+	*h = old[0 : n-1]
+	return x
+}
+
+func (h *IntHeap) Top() int {
+	if (*h).Len() == 0 {
+		return 0
+	}
+
+	return (*h)[0]
+}
+
+/**
+ * Your KthLargest object will be instantiated and called as such:
+ * obj := Constructor(k, nums);
+ * param_1 := obj.Add(val);
+ */
 ```
 
 ### **...**

lcof2/剑指 Offer II 059. 数据流的第 K 大数值/Solution.cpp

@@ -0,0 +1,22 @@
+class KthLargest {
+public:
+    priority_queue<int, vector<int>, greater<int>> q;
+    int size;
+
+    KthLargest(int k, vector<int>& nums) {
+        size = k;
+        for (int num : nums) add(num);
+    }
+    
+    int add(int val) {
+        q.push(val);
+        if (q.size() > size) q.pop();
+        return q.top();
+    }
+};
+
+/**
+ * Your KthLargest object will be instantiated and called as such:
+ * KthLargest* obj = new KthLargest(k, nums);
+ * int param_1 = obj->add(val);
+ */

lcof2/剑指 Offer II 059. 数据流的第 K 大数值/Solution.go

@@ -0,0 +1,73 @@
+type KthLargest struct {
+	h *IntHeap
+	k int
+}
+
+func Constructor(k int, nums []int) KthLargest {
+	h := &IntHeap{}
+	heap.Init(h)
+	for _, v := range nums {
+		heap.Push(h, v)
+	}
+
+	for h.Len() > k {
+		heap.Pop(h)
+	}
+
+	return KthLargest{
+		h: h,
+		k: k,
+	}
+}
+
+func (this *KthLargest) Add(val int) int {
+	heap.Push(this.h, val)
+	for this.h.Len() > this.k {
+		heap.Pop(this.h)
+	}
+
+	return this.h.Top()
+}
+
+func connectSticks(sticks []int) int {
+	h := IntHeap(sticks)
+	heap.Init(&h)
+	res := 0
+	for h.Len() > 1 {
+		val := heap.Pop(&h).(int)
+		val += heap.Pop(&h).(int)
+		res += val
+		heap.Push(&h, val)
+	}
+	return res
+}
+
+type IntHeap []int
+
+func (h IntHeap) Len() int           { return len(h) }
+func (h IntHeap) Less(i, j int) bool { return h[i] < h[j] }
+func (h IntHeap) Swap(i, j int)      { h[i], h[j] = h[j], h[i] }
+func (h *IntHeap) Push(x interface{}) {
+	*h = append(*h, x.(int))
+}
+func (h *IntHeap) Pop() interface{} {
+	old := *h
+	n := len(old)
+	x := old[n-1]
+	*h = old[0 : n-1]
+	return x
+}
+
+func (h *IntHeap) Top() int {
+	if (*h).Len() == 0 {
+		return 0
+	}
+
+	return (*h)[0]
+}
+
+/**
+ * Your KthLargest object will be instantiated and called as such:
+ * obj := Constructor(k, nums);
+ * param_1 := obj.Add(val);
+ */

lcof2/剑指 Offer II 059. 数据流的第 K 大数值/Solution.java

@@ -0,0 +1,26 @@
+class KthLargest {
+    private PriorityQueue<Integer> q;
+    private int size;
+
+    public KthLargest(int k, int[] nums) {
+        q = new PriorityQueue<>(k);
+        size = k;
+        for (int num : nums) {
+            add(num);
+        }
+    }
+    
+    public int add(int val) {
+        q.offer(val);
+        if (q.size() > size) {
+            q.poll();
+        }
+        return q.peek();
+    }
+}
+
+/**
+ * Your KthLargest object will be instantiated and called as such:
+ * KthLargest obj = new KthLargest(k, nums);
+ * int param_1 = obj.add(val);
+ */

lcof2/剑指 Offer II 059. 数据流的第 K 大数值/Solution.py

@@ -0,0 +1,18 @@
+class KthLargest:
+
+    def __init__(self, k: int, nums: List[int]):
+        self.q = []
+        self.size = k
+        for num in nums:
+            self.add(num)
+
+    def add(self, val: int) -> int:
+        heapq.heappush(self.q, val)
+        if len(self.q) > self.size:
+            heapq.heappop(self.q)
+        return self.q[0]
+
+
+# Your KthLargest object will be instantiated and called as such:
+# obj = KthLargest(k, nums)
+# param_1 = obj.add(val)