feat: 堆和前缀和

Author: lucifer

src/codeTemplates/heap.js

@@ -1,17 +1,17 @@
-const minHeapCode = `
+const minHeapJSCode = `
 class MinHeap {
 
     constructor () {
         /* Initialing the array heap and adding a dummy element at index 0 */
         this.heap = [null]
     }
 
-    getMin () {
+    peek() {
         /* Accessing the min element at index 1 in the heap array */
         return this.heap[1]
     }
     
-    insert (node) {
+    push (node) {
 
         /* Inserting the new node at the end of the heap array */
         this.heap.push(node)
@@ -31,7 +31,7 @@ class MinHeap {
         }
     }
     
-    remove() {
+    pop() {
         /* Smallest element is at the index 1 in the heap array */
         let smallest = this.heap[1]
 
@@ -83,25 +83,206 @@ class MinHeap {
     /**
      * Your MinHeap object will be instantiated and called as such:
      * var obj = new MinHeap()
-     * obj.insert(1)
-     * obj.insert(2)
-     * obj.getMin() // will return 1
-     * obj.remove() // remove 1
-     * obj.getMin() // will return 2
+     * obj.push(1)
+     * obj.push(2)
+     * obj.peek() // will return 1
+     * obj.pop() // remove 1
+     * obj.peek() // will return 2
      */ 
 }
 `;
 
+const minHeapPythonCode = `
+class min_heap:
+    def __init__(self):
+        self.h = [0]
+
+    def shift_up(self, i):
+        while i // 2 > 0:
+            if self.h[i] < self.h[i // 2]:
+                self.h[i], self.h[i//2] = self.h[i//2], self.h[i]
+            i = i // 2
+
+    def shift_down(self, i):
+        while (i * 2) <= len(self.h)-1:
+            mc = self.minChild(i)
+            if self.h[i] > self.h[mc]:
+                self.h[i], self.h[mc] = self.h[mc], self.h[i]
+            i = mc
+
+    def minChild(self, i):
+        if i * 2 + 1 > len(self.h)-1:
+            return i * 2
+        if self.h[i*2] < self.h[i*2+1]:
+            return i * 2
+        else:
+            return i * 2 + 1
+
+    def heappop(self):
+        if len(self.h) == 1:
+            return None
+        ans = self.h[1]
+        self.h[1] = self.h[len(self.h)-1]
+        self.h.pop()
+        self.shift_down(1)
+        return ans
+
+    def heappush(self, a):
+        self.h.append(a)
+        self.shift_up(len(self.h)-1)
+
+    def build_heap(self, A):
+        self.h = [0] + A
+        i = 1
+        while (i < len(self.h)):
+            self.shift_down(i)
+            i = i + 1
+
+# 使用：
+
+h = min_heap()
+h.build_heap([5, 6, 2, 3])
+
+h.heappush(1)
+h.heappop() # 1
+h.heappop() # 2
+h.heappush(1)
+h.heappop() # 1
+h.heappop() # 3
+`;
+
+const minHeapJavaCode = `
+// by @CaptainZ
+import java.util.Arrays;
+import java.util.Comparator;
+
+/**
+ * 用完全二叉树来构建 堆
+ * 前置条件 起点为 1
+ * 那么 子节点为  i <<1 和 i<<1 + 1
+ * 核心方法为
+ * shiftdown 交换下沉
+ * shiftup 交换上浮
+ * <p>
+ * build 构建堆
+ */
+
+public class MinHeap {
+
+    int size = 0;
+    int queue[];
+
+    public Heap(int initialCapacity) {
+        if (initialCapacity < 1)
+            throw new IllegalArgumentException();
+        this.queue = new int[initialCapacity];
+    }
+
+    public Heap(int[] arr) {
+        size = arr.length;
+        queue = new int[arr.length + 1];
+        int i = 1;
+        for (int val : arr) {
+            queue[i++] = val;
+        }
+    }
+
+    public void shiftDown(int i) {
+
+        int temp = queue[i];
+
+        while ((i << 1) <= size) {
+            int child = i << 1;
+            // child!=size 判断当前元素是否包含右节点
+            if (child != size && queue[child + 1] < queue[child]) {
+                child++;
+            }
+            if (temp > queue[child]) {
+                queue[i] = queue[child];
+                i = child;
+            } else {
+                break;
+            }
+        }
+        queue[i] = temp;
+    }
+
+
+    public void shiftUp(int i) {
+        int temp = queue[i];
+        while ((i >> 1) > 0) {
+            if (temp < queue[i >> 1]) {
+                queue[i] = queue[i >> 1];
+                i >>= 1;
+            } else {
+                break;
+            }
+        }
+        queue[i] = temp;
+    }
+
+    public int peek() {
+
+        int res = queue[1];
+        return res;
+    }
+
+    public int pop() {
+
+        int res = queue[1];
+
+        queue[1] = queue[size--];
+        shiftDown(1);
+        return res;
+    }
+
+    public void push(int val) {
+        if (size == queue.length - 1) {
+            queue = Arrays.copyOf(queue, size << 1+1);
+        }
+        queue[++size] = val;
+        shiftUp(size);
+    }
+
+    public void buildHeap() {
+        for (int i = size >> 1; i >= 0; i--) {
+            shiftDown(i);
+        }
+    }
+
+    public static void main(String[] args) {
+        int arr[] = new int[]{2,7,4,1,8,1};
+        Heap heap = new Heap(arr);
+        heap.buildHeap();
+        System.out.println(heap.peek());
+        heap.push(5);
+        while (heap.size > 0) {
+            int num = heap.pop();
+            System.out.printf(num + "");
+        }
+    }
+}
+
+
+`;
 module.exports = {
   title: "堆",
   list: [
     {
-      text: "标准堆",
+      text: "小顶堆",
       problems: [],
       codes: [
         {
           language: "js",
-          text: minHeapCode,
+          text: minHeapJSCode,
+        },
+        {
+          language: "py",
+          text: minHeapPythonCode,
+        },
+        {
+          language: "java",
+          text: minHeapJavaCode,
         },
       ],
     },

src/codeTemplates/preSum.js

@@ -0,0 +1,61 @@
+const pre1dJSCode = `
+// 建立
+const pre = [0]
+for(const num of nums) {
+    pre.push(pre[pre.length-1] + num)
+}
+// 使用，等价于 nums[i] + nums[i + 1] + ... + nums[j]
+pre[j+1] - pre[i]
+`;
+
+const pre1dPythonCode = `
+# 建立
+pre = []
+for num in nums:
+    pre.append(pre[-1] + num)
+#  使用，等价于 nums[i] + nums[i + 1] + ... + nums[j]
+pre[j+1] - pre[i] 
+`;
+
+const pre2dPythonCode = `
+m,n = len(matrix), len(matrix[0])
+# 建立
+pre = [[0 for _ in range(n + 1)] for _ in range(m + 1)]
+for i in range(1, m+1):
+    for j in range(1, n +1):
+        pre[i][j] = pre[i-1][j]+ pre[i][j-1] - dp[i-1][j-1] + matrix[i][j]
+
+# 使用，等价于以(x1,y1)为矩阵左上角以(x2,y2)为矩阵右下角的所有格子的和
+pre[x2][y2] + pre[x1-1][y1-1] - pre[x1-1][y2] - pre[x2][y2-1]
+`;
+
+module.exports = {
+  title: "前缀和",
+  list: [
+    {
+      text: "一维前缀和",
+      problems: [],
+      codes: [
+        {
+          language: "js",
+          text: pre1dJSCode,
+        },
+        {
+          language: "py",
+          text: pre1dPythonCode,
+        },
+      ],
+    },
+    {
+      text: "二维前缀和",
+      problems: [],
+      codes: [
+        {
+          language: "py",
+          text: pre2dPythonCode,
+        },
+      ],
+    },
+  ],
+  link: "",
+};