refactor: Replace 'poll' with 'pop' in Heap (#416)

codes/c/chapter_heap/my_heap.c

@@ -86,7 +86,7 @@ int push(maxHeap *h, int val) {
 }
 
 /* 元素出堆 */
-int poll(maxHeap *h) {
+int pop(maxHeap *h) {
     // 判空处理
     if (isEmpty(h)) {
         printf("heap is empty!");
@@ -162,7 +162,7 @@ int main() {
     printHeap(heap->data, heap->size);
 
     /* 堆顶元素出堆 */
-    int top = poll(heap);
+    int top = pop(heap);
     printf("\n堆顶元素 %d 出堆后\n", top);
     printHeap(heap->data, heap->size);
 

codes/cpp/chapter_heap/heap.cpp

@@ -13,7 +13,7 @@ void testPush(priority_queue<int> &heap, int val)
     PrintUtil::printHeap(heap);
 }
 
-void testPoll(priority_queue<int> &heap)
+void testPop(priority_queue<int> &heap)
 {
     int val = heap.top();
     heap.pop();
@@ -43,11 +43,11 @@ int main()
     cout << "\n堆顶元素为 " << peek << endl;
 
     /* 堆顶元素出堆 */
-    testPoll(maxHeap);
+    testPop(maxHeap);
-    testPoll(maxHeap);
+    testPop(maxHeap);
-    testPoll(maxHeap);
+    testPop(maxHeap);
-    testPoll(maxHeap);
+    testPop(maxHeap);
-    testPoll(maxHeap);
+    testPop(maxHeap);
 
     /* 获取堆大小 */
     int size = maxHeap.size();

codes/cpp/chapter_heap/my_heap.cpp

@@ -96,7 +96,7 @@ public:
     }
 
     /* 元素出堆 */
-    void poll() {
+    void pop() {
         // 判空处理
         if (empty()) {
             throw out_of_range("堆为空");
@@ -121,48 +121,35 @@ public:
 };
 
 
-void testPush(MaxHeap maxHeap, int val) {
-    maxHeap.push(val);
-    cout << "\n添加元素 " << val << " 后" << endl;
-    maxHeap.print();
-}
-
-void testPop(MaxHeap maxHeap) {
-    int val = maxHeap.peek();
-    maxHeap.poll();
-    cout << "\n出堆元素为 " << val << endl;
-    maxHeap.print();
-}
-
 /* Driver Code */
 int main() {
     /* 初始化大顶堆 */
     vector<int> vec{9, 8, 6, 6, 7, 5, 2, 1, 4, 3, 6, 2};
-    MaxHeap maxheap(vec);
+    MaxHeap maxHeap(vec);
     cout << "\n输入列表并建堆后" << endl;
-    maxheap.print();
+    maxHeap.print();
 
     /* 获取堆顶元素 */
-    int peek = maxheap.peek();
+    int peek = maxHeap.peek();
     cout << "\n堆顶元素为 " << peek << endl;
 
     /* 元素入堆 */
     int val = 7;
-    maxheap.push(val);
+    maxHeap.push(val);
     cout << "\n元素 " << val << " 入堆后" << endl;
-    maxheap.print();
+    maxHeap.print();
 
     /* 堆顶元素出堆 */
-    peek = maxheap.peek();
+    peek = maxHeap.peek();
-    maxheap.poll();
+    maxHeap.pop();
     cout << "\n堆顶元素 " << peek << " 出堆后" << endl;
-    maxheap.print();
+    maxHeap.print();
 
     /* 获取堆大小 */
-    int size = maxheap.size();
+    int size = maxHeap.size();
     cout << "\n堆元素数量为 " << size << endl;
 
     /* 判断堆是否为空 */
-    bool isEmpty = maxheap.empty();
+    bool isEmpty = maxHeap.empty();
     cout << "\n堆是否为空 " << isEmpty << endl;
 }

codes/csharp/chapter_heap/heap.cs

@@ -18,7 +18,7 @@ public class heap
         PrintUtil.printHeap(heap);
     }
 
-    public void testPoll(PriorityQueue<int, int> heap)
+    public void testPop(PriorityQueue<int, int> heap)
     {
         int val = heap.Dequeue(); // 堆顶元素出堆
         Console.WriteLine($"\n堆顶元素 {val} 出堆后\n");
@@ -47,11 +47,11 @@ public class heap
 
         /* 堆顶元素出堆 */
         // 出堆元素会形成一个从大到小的序列
-        testPoll(maxHeap);
+        testPop(maxHeap);
-        testPoll(maxHeap);
+        testPop(maxHeap);
-        testPoll(maxHeap);
+        testPop(maxHeap);
-        testPoll(maxHeap);
+        testPop(maxHeap);
-        testPoll(maxHeap);
+        testPop(maxHeap);
 
         /* 获取堆大小 */
         int size = maxHeap.Count;

codes/csharp/chapter_heap/my_heap.cs

@@ -97,7 +97,7 @@ class MaxHeap
     }
 
     /* 元素出堆 */
-    public int poll()
+    public int pop()
     {
         // 判空处理
         if (isEmpty())
@@ -168,7 +168,7 @@ public class my_heap
         maxHeap.print();
 
         /* 堆顶元素出堆 */
-        peek = maxHeap.poll();
+        peek = maxHeap.pop();
         Console.WriteLine($"堆顶元素 {peek} 出堆后");
         maxHeap.print();
 

codes/go/chapter_heap/heap_test.go

@@ -76,7 +76,7 @@ func TestMyHeap(t *testing.T) {
 	maxHeap.print()
 
 	/* 堆顶元素出堆 */
-	peek = maxHeap.poll()
+	peek = maxHeap.pop()
 	fmt.Printf("\n堆顶元素 %d 出堆后\n", peek)
 	maxHeap.print()
 

codes/go/chapter_heap/my_heap.go

@@ -94,7 +94,7 @@ func (h *maxHeap) siftUp(i int) {
 }
 
 /* 元素出堆 */
-func (h *maxHeap) poll() any {
+func (h *maxHeap) pop() any {
 	// 判空处理
 	if h.isEmpty() {
 		fmt.Println("error")

codes/go/chapter_tree/binary_tree_bfs.go

@@ -18,7 +18,7 @@ func levelOrder(root *TreeNode) []int {
 	// 初始化一个切片，用于保存遍历序列
 	nums := make([]int, 0)
 	for queue.Len() > 0 {
-		// poll
+		// 队首元素出队
 		node := queue.Remove(queue.Front()).(*TreeNode)
 		// 保存结点值
 		nums = append(nums, node.Val)

codes/go/pkg/tree_node.go

@@ -36,7 +36,7 @@ func ArrToTree(arr []any) *TreeNode {
 	queue.PushBack(root)
 	i := 0
 	for queue.Len() > 0 {
-		// poll
+		// 队首元素出队
 		node := queue.Remove(queue.Front()).(*TreeNode)
 		i++
 		if i < len(arr) {

codes/java/chapter_heap/heap.java

@@ -12,12 +12,12 @@ import java.util.*;
 
 public class heap {
     public static void testPush(Queue<Integer> heap, int val) {
-        heap.add(val); // 元素入堆
+        heap.offer(val); // 元素入堆
         System.out.format("\n元素 %d 入堆后\n", val);
         PrintUtil.printHeap(heap);
     }
 
-    public static void testPoll(Queue<Integer> heap) {
+    public static void testPop(Queue<Integer> heap) {
         int val = heap.poll(); // 堆顶元素出堆
         System.out.format("\n堆顶元素 %d 出堆后\n", val);
         PrintUtil.printHeap(heap);
@@ -44,11 +44,11 @@ public class heap {
         System.out.format("\n堆顶元素为 %d\n", peek);
 
         /* 堆顶元素出堆 */
-        testPoll(maxHeap);
+        testPop(maxHeap);
-        testPoll(maxHeap);
+        testPop(maxHeap);
-        testPoll(maxHeap);
+        testPop(maxHeap);
-        testPoll(maxHeap);
+        testPop(maxHeap);
-        testPoll(maxHeap);
+        testPop(maxHeap);
 
         /* 获取堆大小 */
         int size = maxHeap.size();

codes/java/chapter_heap/my_heap.java

@@ -87,7 +87,7 @@ class MaxHeap {
     }
 
     /* 元素出堆 */
-    public int poll() {
+    public int pop() {
         // 判空处理
         if (isEmpty())
             throw new EmptyStackException();
@@ -129,18 +129,6 @@ class MaxHeap {
 
 
 public class my_heap {
-    public static void testPush(MaxHeap maxHeap, int val) {
-        maxHeap.push(val);  // 元素入堆
-        System.out.format("\n添加元素 %d 后\n", val);
-        maxHeap.print();
-    }
-
-    public static void testPoll(MaxHeap maxHeap) {
-        int val = maxHeap.poll(); // 堆顶元素出堆
-        System.out.format("\n出堆元素为 %d\n", val);
-        maxHeap.print();
-    }
-
     public static void main(String[] args) {
         /* 初始化大顶堆 */
         MaxHeap maxHeap = new MaxHeap(Arrays.asList(9, 8, 6, 6, 7, 5, 2, 1, 4, 3, 6, 2));
@@ -158,7 +146,7 @@ public class my_heap {
         maxHeap.print();
 
         /* 堆顶元素出堆 */
-        peek = maxHeap.poll();
+        peek = maxHeap.pop();
         System.out.format("\n堆顶元素 %d 出堆后\n", peek);
         maxHeap.print();
 

codes/javascript/chapter_heap/my_heap.js

@@ -82,7 +82,7 @@ class MaxHeap {
     }
 
     /* 元素出堆 */
-    poll() {
+    pop() {
         // 判空处理
         if (this.isEmpty()) throw new Error("堆为空");
         // 交换根结点与最右叶结点（即交换首元素与尾元素）
@@ -119,18 +119,6 @@ class MaxHeap {
     }
 }
 
-function testPush(maxHeap, val) {
-    maxHeap.push(val); // 元素入堆
-    console.log(`\n添加元素 ${val} 后`);
-    maxHeap.print();
-}
-
-function testPoll(maxHeap) {
-    let val = maxHeap.poll(); // 堆顶元素出堆
-    console.log(`\n出堆元素为 ${val}`);
-    maxHeap.print();
-}
-
 /* Driver Code */
 /* 初始化大顶堆 */
 const maxHeap = new MaxHeap([9, 8, 6, 6, 7, 5, 2, 1, 4, 3, 6, 2]);
@@ -148,7 +136,7 @@ console.log(`\n元素 ${val} 入堆后`);
 maxHeap.print();
 
 /* 堆顶元素出堆 */
-peek = maxHeap.poll();
+peek = maxHeap.pop();
 console.log(`\n堆顶元素 ${peek} 出堆后`);
 maxHeap.print();
 

codes/python/chapter_heap/my_heap.py

@@ -67,7 +67,7 @@ class MaxHeap:
             # 循环向上堆化
             i = p
 
-    def poll(self) -> int:
+    def pop(self) -> int:
         """ 元素出堆 """
         # 判空处理
         assert not self.is_empty()
@@ -102,18 +102,6 @@ class MaxHeap:
         print_heap(self.max_heap)
 
 
-def test_push(max_heap: MaxHeap, val: int):
-    max_heap.push(val)  # 元素入堆
-    print(f"\n添加元素 {val} 后\n")
-    max_heap.print()
-
-
-def test_poll(max_heap: MaxHeap):
-    val = max_heap.poll()  # 堆顶元素出堆
-    print(f"\n出堆元素为 {val}\n")
-    max_heap.print()
-
-
 """ Driver Code """
 if __name__ == "__main__":
     # 初始化大顶堆
@@ -132,7 +120,7 @@ if __name__ == "__main__":
     max_heap.print()
 
     # 堆顶元素出堆
-    peek = max_heap.poll()
+    peek = max_heap.pop()
     print(f"\n堆顶元素 {peek} 出堆后")
     max_heap.print()
 

codes/swift/chapter_heap/my_heap.swift

@@ -81,7 +81,7 @@ class MaxHeap {
     }
 
     /* 元素出堆 */
-    func poll() -> Int {
+    func pop() -> Int {
         // 判空处理
         if isEmpty() {
             fatalError("堆为空")
@@ -148,7 +148,7 @@ enum MyHeap {
         maxHeap.print()
 
         /* 堆顶元素出堆 */
-        peek = maxHeap.poll()
+        peek = maxHeap.pop()
         print("\n堆顶元素 \(peek) 出堆后")
         maxHeap.print()
 

codes/typescript/chapter_heap/my_heap.ts

@@ -81,7 +81,7 @@ class MaxHeap {
     }
 
     /* 元素出堆 */
-    public poll(): number {
+    public pop(): number {
         // 判空处理
         if (this.isEmpty()) throw new RangeError('Heap is empty.');
         // 交换根结点与最右叶结点（即交换首元素与尾元素）
@@ -118,18 +118,6 @@ class MaxHeap {
     }
 }
 
-function testPush(maxHeap: MaxHeap, val: number): void {
-    maxHeap.push(val); // 元素入堆
-    console.log(`\n添加元素 ${val} 后`);
-    maxHeap.print();
-}
-
-function testPoll(maxHeap: MaxHeap): void {
-    const val = maxHeap.poll(); // 堆顶元素出堆
-    console.log(`\n出堆元素为 ${val}`);
-    maxHeap.print();
-}
-
 /* Driver Code */
 /* 初始化大顶堆 */
 const maxHeap = new MaxHeap([9, 8, 6, 6, 7, 5, 2, 1, 4, 3, 6, 2]);
@@ -147,7 +135,7 @@ console.log(`\n元素 ${val} 入堆后`);
 maxHeap.print();
 
 /* 堆顶元素出堆 */
-peek = maxHeap.poll();
+peek = maxHeap.pop();
 console.log(`\n堆顶元素 ${peek} 出堆后`);
 maxHeap.print();
 

codes/zig/chapter_heap/my_heap.zig

@@ -94,7 +94,7 @@ pub fn MaxHeap(comptime T: type) type {
         }
 
         // 元素出堆
-        pub fn poll(self: *Self) !T {
+        pub fn pop(self: *Self) !T {
             // 判断处理
             if (self.isEmpty()) unreachable;
             // 交换根结点与最右叶结点（即交换首元素与尾元素）
@@ -171,7 +171,7 @@ pub fn main() !void {
     try maxHeap.print(mem_allocator);
 
     // 堆顶元素出堆
-    peek = try maxHeap.poll();
+    peek = try maxHeap.pop();
     std.debug.print("\n堆顶元素 {} 出堆后\n", .{peek});
     try maxHeap.print(mem_allocator);
 

docs/chapter_heap/heap.md

@@ -19,17 +19,17 @@
 
 而恰好，**堆的定义与优先队列的操作逻辑完全吻合**，大顶堆就是一个元素从大到小出队的优先队列。从使用角度看，我们可以将「优先队列」和「堆」理解为等价的数据结构。因此，本文与代码对两者不做特别区分，统一使用「堆」来命名。
 
-堆的常用操作见下表（方法命名以 Java 为例）。
+堆的常用操作见下表，方法名需根据编程语言确定。
 
 <div class="center-table" markdown>
 
-| 方法      | 描述                                         | 时间复杂度  |
+| 方法名     | 描述                                         | 时间复杂度  |
-| --------- | -------------------------------------------- | ----------- |
+| --------- | ------------------------------------------ | ----------- |
-| add()     | 元素入堆                                     | $O(\log n)$ |
+| push()    | 元素入堆                                    | $O(\log n)$ |
-| poll()    | 堆顶元素出堆                                 | $O(\log n)$ |
+| pop()     | 堆顶元素出堆                                   | $O(\log n)$ |
-| peek()    | 访问堆顶元素（大 / 小顶堆分别为最大 / 小值） | $O(1)$      |
+| peek()    | 访问堆顶元素（大 / 小顶堆分别为最大 / 小值）       | $O(1)$      |
-| size()    | 获取堆的元素数量                             | $O(1)$      |
+| size()    | 获取堆的元素数量                               | $O(1)$      |
-| isEmpty() | 判断堆是否为空                               | $O(1)$      |
+| isEmpty() | 判断堆是否为空                                 | $O(1)$      |
 
 </div>
 
@@ -49,11 +49,11 @@
     Queue<Integer> maxHeap = new PriorityQueue<>((a, b) -> b - a);
     
     /* 元素入堆 */
-    maxHeap.add(1);
+    maxHeap.offer(1);
-    maxHeap.add(3);
+    maxHeap.offer(3);
-    maxHeap.add(2);
+    maxHeap.offer(2);
-    maxHeap.add(5);
+    maxHeap.offer(5);
-    maxHeap.add(4);
+    maxHeap.offer(4);
     
     /* 获取堆顶元素 */
     int peek = maxHeap.peek(); // 5
@@ -217,11 +217,11 @@
 
         /* 堆顶元素出堆 */
         // 调用 heap.Interface 的方法，来移除元素
-        heap.Pop(maxHeap)
+        heap.Pop(maxHeap) // 5
-        heap.Pop(maxHeap)
+        heap.Pop(maxHeap) // 4
-        heap.Pop(maxHeap)
+        heap.Pop(maxHeap) // 3
-        heap.Pop(maxHeap)
+        heap.Pop(maxHeap) // 2
-        heap.Pop(maxHeap)
+        heap.Pop(maxHeap) // 1
 
         /* 获取堆大小 */
         size := len(*maxHeap)
@@ -236,13 +236,13 @@
 === "JavaScript"
 
     ```javascript title="heap.js"
-    // JavaScript 未提供内置 heap 类
+    // JavaScript 未提供内置 Heap 类
     ```
 
 === "TypeScript"
 
     ```typescript title="heap.ts"
-    // TypeScript 未提供内置堆 Heap 类
+    // TypeScript 未提供内置 Heap 类
     ```
 
 === "C"
@@ -291,7 +291,7 @@
 === "Swift"
 
     ```swift title="heap.swift"
-    // Swift 未提供内置 heap 类
+    // Swift 未提供内置 Heap 类
     ```
 
 === "Zig"
@@ -597,41 +597,41 @@
 顾名思义，**从顶至底堆化的操作方向与从底至顶堆化相反**，我们比较根结点的值与其两个子结点的值，将最大的子结点与根结点执行交换，并循环以上操作，直到越过叶结点时结束，或当遇到无需交换的结点时提前结束。
 
 === "<1>"
-    ![堆顶元素出堆步骤](heap.assets/heap_poll_step1.png)
+    ![堆顶元素出堆步骤](heap.assets/heap_pop_step1.png)
 
 === "<2>"
-    ![heap_poll_step2](heap.assets/heap_poll_step2.png)
+    ![heap_pop_step2](heap.assets/heap_pop_step2.png)
 
 === "<3>"
-    ![heap_poll_step3](heap.assets/heap_poll_step3.png)
+    ![heap_pop_step3](heap.assets/heap_pop_step3.png)
 
 === "<4>"
-    ![heap_poll_step4](heap.assets/heap_poll_step4.png)
+    ![heap_pop_step4](heap.assets/heap_pop_step4.png)
 
 === "<5>"
-    ![heap_poll_step5](heap.assets/heap_poll_step5.png)
+    ![heap_pop_step5](heap.assets/heap_pop_step5.png)
 
 === "<6>"
-    ![heap_poll_step6](heap.assets/heap_poll_step6.png)
+    ![heap_pop_step6](heap.assets/heap_pop_step6.png)
 
 === "<7>"
-    ![heap_poll_step7](heap.assets/heap_poll_step7.png)
+    ![heap_pop_step7](heap.assets/heap_pop_step7.png)
 
 === "<8>"
-    ![heap_poll_step8](heap.assets/heap_poll_step8.png)
+    ![heap_pop_step8](heap.assets/heap_pop_step8.png)
 
 === "<9>"
-    ![heap_poll_step9](heap.assets/heap_poll_step9.png)
+    ![heap_pop_step9](heap.assets/heap_pop_step9.png)
 
 === "<10>"
-    ![heap_poll_step10](heap.assets/heap_poll_step10.png)
+    ![heap_pop_step10](heap.assets/heap_pop_step10.png)
 
 与元素入堆操作类似，**堆顶元素出堆操作的时间复杂度为 $O(\log n)$** 。
 
 === "Java"
 
     ```java title="my_heap.java"
-    [class]{MaxHeap}-[func]{poll}
+    [class]{MaxHeap}-[func]{pop}
 
     [class]{MaxHeap}-[func]{siftDown}
     ```
@@ -639,7 +639,7 @@
 === "C++"
 
     ```cpp title="my_heap.cpp"
-    [class]{MaxHeap}-[func]{poll}
+    [class]{MaxHeap}-[func]{pop}
 
     [class]{MaxHeap}-[func]{siftDown}
     ```
@@ -647,7 +647,7 @@
 === "Python"
 
     ```python title="my_heap.py"
-    [class]{MaxHeap}-[func]{poll}
+    [class]{MaxHeap}-[func]{pop}
 
     [class]{MaxHeap}-[func]{sift_down}
     ```
@@ -655,7 +655,7 @@
 === "Go"
 
     ```go title="my_heap.go"
-    [class]{maxHeap}-[func]{poll}
+    [class]{maxHeap}-[func]{pop}
 
     [class]{maxHeap}-[func]{siftDown}
     ```
@@ -663,7 +663,7 @@
 === "JavaScript"
 
     ```javascript title="my_heap.js"
-    [class]{MaxHeap}-[func]{poll}
+    [class]{MaxHeap}-[func]{pop}
 
     [class]{MaxHeap}-[func]{#siftDown}
     ```
@@ -671,7 +671,7 @@
 === "TypeScript"
 
     ```typescript title="my_heap.ts"
-    [class]{MaxHeap}-[func]{poll}
+    [class]{MaxHeap}-[func]{pop}
 
     [class]{MaxHeap}-[func]{siftDown}
     ```
@@ -679,7 +679,7 @@
 === "C"
 
     ```c title="my_heap.c"
-    [class]{maxHeap}-[func]{poll}
+    [class]{maxHeap}-[func]{pop}
 
     [class]{maxHeap}-[func]{siftDown}
     ```
@@ -687,7 +687,7 @@
 === "C#"
 
     ```csharp title="my_heap.cs"
-    [class]{MaxHeap}-[func]{poll}
+    [class]{MaxHeap}-[func]{pop}
 
     [class]{MaxHeap}-[func]{siftDown}
     ```
@@ -695,7 +695,7 @@
 === "Swift"
 
     ```swift title="my_heap.swift"
-    [class]{MaxHeap}-[func]{poll}
+    [class]{MaxHeap}-[func]{pop}
 
     [class]{MaxHeap}-[func]{siftDown}
     ```
@@ -703,7 +703,7 @@
 === "Zig"
 
     ```zig title="my_heap.zig"
-    [class]{MaxHeap}-[func]{poll}
+    [class]{MaxHeap}-[func]{pop}
 
     [class]{MaxHeap}-[func]{siftDown}
     ```