最小堆定時器

最小堆（Min Heap）是一種特殊的堆，其中任何節點的關鍵字都不會大於其父節點的關鍵字。最小堆可以用來實現一個優先級佇列，其中隊首元素總是最小的。最小堆也被稱為先進先出（FIFO）堆，因為它們按照插入的順序保留元素。

最小堆可以用來實現一個定時器，其中每個元素對應一個到期時間。當添加一個新的定時器時，它會被插入到堆中，並且堆會保持最小堆的特性。當堆中的某個定時器到期時，它會被移除，並且堆會重新調整以保持最小堆的特性。

以下是一個簡單的C++最小堆定時器實現示例：

#include <iostream>
#include <vector>
#include <algorithm>

template <typename T>
class MinHeapTimer {
private:
    struct TimerNode {
        T time;
        std::function<void()> callback;
    };

    std::vector<TimerNode> m_heap;
    size_t m_size;

    void swap(size_t i, size_t j) {
        TimerNode tmp = m_heap[i];
        m_heap[i] = m_heap[j];
        m_heap[j] = tmp;
    }

    void siftDown(size_t start) {
        size_t i = start;
        size_t j = 2 * i + 1;

        while (j < m_size) {
            if (j + 1 < m_size && m_heap[j + 1].time < m_heap[j].time) {
                ++j;
            }

            if (m_heap[i].time <= m_heap[j].time) {
                break;
            }

            swap(i, j);
            i = j;
            j = 2 * i + 1;
        }
    }

    void siftUp(size_t end) {
        size_t i = end;
        size_t j = i / 2;

        while (j > 0 && m_heap[j].time < m_heap[i].time) {
            swap(j, i);
            i = j;
            j = i / 2;
        }
    }

public:
    MinHeapTimer() : m_size(0) {}

    void addTimer(const T& time, const std::function<void()>& callback) {
        m_heap.emplace_back(TimerNode{time, callback});
        siftUp(m_size++);
    }

    void removeExpiredTimers() {
        while (m_heap[0].time <= m_heap[m_size - 1].time) {
            std::swap(m_heap[0], m_heap[m_size - 1]);
            m_heap[m_size - 1].callback();
            m_size--;
            siftDown(0);
        }
    }

    size_t size() const {
        return m_size;
    }
};

int main() {
    MinHeapTimer<int> timer;

    timer.addTimer(10, []{ std::cout << "Timer 10 expired\n"; });
    timer.addTimer(5, []{ std::cout << "Timer 5 expired\n"; });
    timer.addTimer(15, []{ std::cout << "Timer 15 expired\n"; });

    for (int i = 0; i < 10; ++i) {
        timer.removeExpiredTimers();
    }

    return 0;
}

這個示例中，MinHeapTimer 類實現了一個最小堆定時器。addTimer 方法用來添加一個新的定時器，removeExpiredTimers 方法用來移除所有過期的定時器。main 方法中，我們添加了三個定時器，然後調用了 removeExpiredTimers 方法 10 次，這會導致第一個和第二個定時器被移除，因為它們已經到期。

請注意，這個示例假設 T 是一個可以進行比較的類型，例如 int 或 std::chrono::steady_clock::time_point。如果你的類型不支持比較，你可能需要定義一個比較函數來比較到期時間。