Add C++ solutions for Chapter 8 (Heaps)

ongshunping · ongshunping · commit f73e7a0a7d3b · 2025-01-16T17:16:30.000+08:00
diff --git a/cpp/Heaps/combine_sorted_linked_lists.cpp b/cpp/Heaps/combine_sorted_linked_lists.cpp
@@ -0,0 +1,45 @@
+#include <vector>
+#include <queue>
+#include "ds/ListNode.h"
+using ds::ListNode;
+
+/**
+ * Definition of ListNode:
+ * struct ListNode {
+ *     int val;
+ *     ListNode* next;
+ *     ListNode(int val = 0, ListNode* next = nullptr) : val(val), next(next) {}
+ * };
+ */
+
+ListNode* combineSortedLinkedLists(std::vector<ListNode*>& lists) {
+    // Min-heap (priority queue) storing (node value, node pointer) pairs.
+    // std::pair's built-in comparison ensures the heap is ordered by value.
+    typedef std::pair<int, ListNode*> NodePair;
+    std::priority_queue<NodePair, std::vector<NodePair>, std::greater<NodePair>> heap;
+    // Push the head of each linked list into the heap.
+    for (ListNode* head : lists) {
+        if (head) {
+            heap.push(std::make_pair(head->val, head));
+        }
+    }
+    // Set a dummy node to point to the head of the output linked list.
+    ListNode dummy(-1);
+    // Create a pointer to iterate through the combined linked list as 
+    // we add nodes to it.
+    ListNode* curr = &dummy;
+    while (!heap.empty()) {
+        // Pop the node with the smallest value from the heap and add it 
+        // to the output linked list.
+        NodePair smallestNodePair = heap.top();
+        heap.pop();
+        ListNode* smallestNode = smallestNodePair.second;
+        curr->next = smallestNode;
+        curr = curr->next;
+        // Push the popped node's subsequent node to the heap.
+        if (smallestNode->next) {
+            heap.push(std::make_pair(smallestNode->next->val, smallestNode->next));
+        }
+    }
+    return dummy.next;
+}
diff --git a/cpp/Heaps/k_most_frequent_strings_max_heap.cpp b/cpp/Heaps/k_most_frequent_strings_max_heap.cpp
@@ -0,0 +1,39 @@
+#include <vector>
+#include <string>
+#include <unordered_map>
+#include <queue>
+
+std::vector<std::string> kMostFrequentStringsMaxHeap(std::vector<std::string>& strs, int k) {
+    // Create a hash map that counts the frequency of each string.
+    std::unordered_map<std::string, int> freqs;
+    for (auto& str : strs) {
+        freqs[str]++;
+    }
+    // Define a custom comparator for the priority queue. 
+    auto cmp = [](std::pair<int, std::string>& a, std::pair<int, std::string>& b) {
+        // Prioritize lexicographical order for strings with equal 
+        // frequencies. 
+        if (a.first == b.first) {
+            return a.second > b.second;
+        }
+        // Otherwise, prioritize strings with higher frequencies.
+        return a.first < b.first;
+    }; 
+    // Create the max heap using the comparator and push all 
+    // frequency-string pairs into the heap. Take note that 
+    // std::priority_queue is inherently a max-heap.
+    std::priority_queue<std::pair<int, std::string>,
+                        std::vector<std::pair<int, std::string>>,
+                        decltype(cmp)> maxHeap(cmp);
+    for (auto& entry : freqs) {
+        maxHeap.push(std::make_pair(entry.second, entry.first));
+    }
+    // Pop the most frequent string off the heap 'k' times and return 
+    // these 'k' most frequent strings.
+    std::vector<std::string> res;
+    for (int i = 0; i < k && !maxHeap.empty(); i++) {
+        res.push_back(maxHeap.top().second);
+        maxHeap.pop();
+    }
+    return res;
+}
diff --git a/cpp/Heaps/k_most_frequent_strings_min_heap.cpp b/cpp/Heaps/k_most_frequent_strings_min_heap.cpp
@@ -0,0 +1,46 @@
+#include <vector>
+#include <string>
+#include <unordered_map>
+#include <queue>
+#include <algorithm>
+
+std::vector<std::string> kMostFrequentStringsMinHeap(std::vector<std::string>& strs, int k) {
+    std::unordered_map<std::string, int> freqs;
+    for (auto& str : strs) {
+        freqs[str]++;
+    }
+    // Since this is a min-heap comparator, we can use the same 
+    // comparator as the one used in the max-heap, but reversing the 
+    // inequality signs to invert the priority.
+    auto cmp = [](std::pair<int, std::string>& a, std::pair<int, std::string>& b) {
+        if (a.first == b.first) {
+            return a.second < b.second; 
+        }
+        return a.first > b.first; 
+    };
+    std::priority_queue<
+        std::pair<int, std::string>,
+        std::vector<std::pair<int, std::string>>,
+        decltype(cmp)
+    > minHeap(cmp);
+    for (auto& entry : freqs) {
+        minHeap.push(std::make_pair(entry.second, entry.first));
+        // If heap size exceeds 'k', pop the lowest frequency string to 
+        // ensure the heap only contains the 'k' most frequent words so 
+        // far.
+        if (minHeap.size() > k) {
+            minHeap.pop();
+        }
+    }
+    // Return the 'k' most frequent strings by popping the remaining 'k' 
+    // strings from the heap. Since we're using a min-heap, we need to 
+    // reverse the result after popping the elements to ensure the most 
+    // frequent strings are listed first.
+    std::vector<std::string> res;
+    for (int i = 0; i < k && !minHeap.empty(); i++) {
+        res.push_back(minHeap.top().second);
+        minHeap.pop();
+    }
+    std::reverse(res.begin(), res.end());
+    return res;
+}
diff --git a/cpp/Heaps/median_of_an_integer_stream.cpp b/cpp/Heaps/median_of_an_integer_stream.cpp
@@ -0,0 +1,43 @@
+#include <queue>
+#include <vector>
+
+class MedianOfAnIntegerStream {
+public:
+    MedianOfAnIntegerStream() {}
+    
+    void add(int num) {
+        // If 'num' is less than or equal to the max of 'leftHalf', it 
+        // belongs to the left half.
+        if (leftHalf.empty() || num <= leftHalf.top()) {
+            leftHalf.push(num);
+            // Rebalance the heaps if the size of 'leftHalf' 
+            // exceeds the size of 'rightHalf' by more than one.
+            if (leftHalf.size() > rightHalf.size() + 1) {
+                rightHalf.push(leftHalf.top());
+                leftHalf.pop();
+            }
+        } else {
+            // Otherwise, it belongs to the right half.
+            rightHalf.push(num);
+            // Rebalance the heaps if 'rightHalf' is larger than 
+            // 'leftHalf'.
+            if (leftHalf.size() < rightHalf.size()) {
+                leftHalf.push(rightHalf.top());
+                rightHalf.pop();
+            }
+        }
+    }
+
+    double getMedian() {
+        if (leftHalf.size() == rightHalf.size()) {
+            return (leftHalf.top() + rightHalf.top()) / 2.0;
+        }
+        return leftHalf.top();
+    }
+
+private:
+    // Max-heap for the left half. 
+    std::priority_queue<int> leftHalf;
+    // Min-heap for the right half. 
+    std::priority_queue<int, std::vector<int>, std::greater<int>> rightHalf;
+};
diff --git a/cpp/Heaps/sort_a_k_sorted_array.cpp b/cpp/Heaps/sort_a_k_sorted_array.cpp
@@ -0,0 +1,27 @@
+#include <vector>
+#include <queue>
+
+std::vector<int> sortAKSortedArray(std::vector<int>& nums, int k) {
+    // Populate a min-heap with the first k + 1 values in 'nums'.
+    std::priority_queue<int, std::vector<int>, std::greater<int>> minHeap;
+    int n = nums.size();
+    for (int i = 0; i <= k && i < n; i++) {
+        minHeap.push(nums[i]);
+    }
+    // Replace elements in the array with the minimum from the heap at each 
+    // iteration. 
+    int insertIndex = 0;
+    for (int i = k + 1; i < n; i++) {
+        nums[insertIndex] = minHeap.top();
+        minHeap.pop();
+        insertIndex++;
+        minHeap.push(nums[i]);
+    }
+    // Pop the remaining elements from the heap to finish sorting the array.
+    while (!minHeap.empty()) {
+        nums[insertIndex] = minHeap.top();
+        minHeap.pop();
+        insertIndex++;
+    }
+    return nums;
+}
