最小堆及其應用：時間堆

一、 堆

1. 概念

堆是一種經過排序的完全二叉樹，其中任一非終端節點的資料值均不大於（或不小於）其左子節點和右子節點的值。

其中，兩個葉子節點的大小沒有順序。

堆又分為兩種，最大堆、最小堆。由上面的概念我們可以知道：
- 最大堆： 任一非葉子節點的值均大於其左子節點和右子節點的值。
- 最小堆： 任一非葉子節點的值均小於其左子節點和右子節點的值。

（圖為最小堆）

因此，我們可以得到：最大堆的根節點的值是最大的，最小堆的根節點的值是最小的。所以在需要最值問題的時候，我們可以採用堆這種資料結構來處理。

2. 最小堆的實現

由於堆是一種經過排序的完全二叉樹，因此在構建的時候需要對新插入的節點進行一些操作以使其符合堆的性質。這種操作就是節點的上濾與下濾。以最小堆為例：

• 上濾: 將當前節點與其父節點相比，如果當前節點的值比較小，就把當前節點與父節點交換，繼續前面的比較，知道當前節點的值比父節點的值大為止。此時，便符合最小堆的定義。

• 下濾： 將當前節點與其左、右子節點相比，如果當前節點的值比其中一個（或兩個）子節點的值大，就把當前節點與兩個子節點中較小的那個交換，繼續前面的比較，知道當前節點的值比兩個子節點的值都小為止。此時，便符合最小堆的定義。

下濾是將堆上面不符合條件的節點向下移動的過程，上濾則是將堆下面不符合條件的節點向上移動的過程。

交換後：

3. 性質

• 用陣列模擬堆：對於第i個節點，其左子節點的位置是2i + 1， 右子節點的位置是2i + 2。

• 對於具有N個節點的完全二叉樹，其葉子節點有( N + 1 ) / 2個，非葉子節點有N / 2個。

• 由於在建立最小堆時，只要保證每個節點的值比其左右子節點都小即可，因此在建立最小堆時，只要從最下層開始，遍歷前N / 2個非葉子節點( [ 0 ~ n/2-1 ] )進行下濾即可。（前提是已經有陣列，不是每次向陣列後面新增元素；葉子節點會由於其父節點的下濾而變得有序）

4. 程式碼

template< typename T >
void percolate_down( vector
 
<T>& array,  int hole, int n ) {
    T tmp = array[hole];
    int child = 0;
    for( ; hole * 2 + 1 < n; hole = child ) {
        child = hole * 2 + 1;
        if( child < n-1 && array[child] > array[child+1] ) {  // 右子節點較小
            child++;  // 將節點切換到右子節點
        }
        if( tmp > array[child] ) {  // 子樹的根節點值大於子節點值
            array[hole] = array[child];
        } else {  // tmp節點的值最小，符合
            break;
        }
    }
    array[hole] = tmp;  // 將最初的節點放到合適的位置
}

/* 主函式用於建立最小堆的示例程式碼

vector<int> t { 3, 6, 2, 1, 5, 4, ７ };
int n = t.size();

for( int i = n/2 - 1; i >= 0; i-- ) {
    percolate_down( t, i, t.size() );
}

*/

二、時間堆

1. 概念簡述

由於定時器的觸發是由於時間到了，因此只有時間最短的定時器會首先被觸發，通過這個原理，我們可以採用最小堆，將按時間順序排序，堆頂元素是時間最短的定時器，因此只要判斷堆頂元素是否被觸發即可。只有堆頂定時器的時間到了，才會到其他時間較晚的定時器的時間。

2. 實現細節

• 堆頂節點的刪除：將堆頂節點刪除，就會留有一個空位置，因此可以將最後一個節點放到堆頂位置，再對堆頂節點進行下濾，就可以確保構成最小堆。

• 使用陣列來模擬堆的實現，相比於連結串列而言，不僅節省空間，而且更容易實現堆的插入、刪除操作。如上面圖片中的最小堆，可以用陣列表示為：

• 由於非葉子結點有N/2 - 1個，因此只要保證這些節點構成的子樹具有堆性質，就能保證整棵樹具有堆性質。（因為非葉子結點的下濾會將葉子節點也變的具有堆性質）

3. 程式碼

#ifndef _TIMEHEAP_H_
#define _TIMEHEAP_H_

#include <iostream>
#include <netinet/in.h>
#include <time.h>

const int BUFFER_SIZE = 64;

class HeapTimer;

// 使用者資料，繫結socket和定時器
struct client_data {
    sockaddr_in address;
    int sock_fd;
    char buf[BUFFER_SIZE];
    HeapTimer* timer;
};

// 定時器類
class HeapTimer {
public: 
    time_t expire;  // 定時器生效的絕對時間
    client_data* user_data;
public: 
    HeapTimer( int delay ) {
        expire = time( NULL ) + delay;
    }
    void ( *cb_func ) ( client_data* );  // 定時器的回撥函式
};

class TimeHeap {
private: 
    HeapTimer** array;  // 堆陣列
    int capacity;  // 堆陣列容量
    int cur_size; // 堆陣列當前包含元素個數
public: 
    TimeHeap( int cap );  // 建構函式1，初始化大小為cap的空陣列
    TimeHeap( HeapTimer** init_array, int size, int cap ); // 建構函式2，根據已有陣列初始化堆
    ~TimeHeap();
public:
    void percolate_down( int hole );  // 對堆結點進行下慮
    void add_timer( HeapTimer* timer );
    void del_timer( HeapTimer* timer );
    void pop_timer();
    void tick();

    void resize();
};

TimeHeap::TimeHeap( int cap ) : capacity(cap), cur_size(0) {
    array = new HeapTimer*[ capacity ];
    if( !array ) {
        throw std::exception();
    }

    for( int i = 0; i < capacity; i++ ) {
        array[i] = nullptr;
    }
}

TimeHeap::TimeHeap( HeapTimer** init_array, int size, int cap ) : cur_size(size), capacity(cap) {
    if( capacity < size ) {
        throw std::exception();
    }

    array = new HeapTimer*[ capacity ];
    if( !array ) {
        throw std::exception();
    }

    for( int i = 0; i < size; i++ ) {
        array[i] = init_array[i];
    }

    // 因為會比較當前節點與子節點，所以只從最下層遍歷非葉子節點即可
    for( int i = size/2 - 1; i >= 0 ; i-- ) {
        percolate_down( i );
    }
}

TimeHeap::~TimeHeap() {
    for( int i = 0; i < cur_size; i++ ) {
        if( !array[i] ) {
            delete array[i];
        } 
    }
    delete[] array;
}

// 對堆結點進行下濾，確保第hole個節點滿足最小堆性質
void TimeHeap::percolate_down( int hole ) {
    HeapTimer* tmp = array[hole];
    int child = 0;
    for( ; hole * 2 + 1 < cur_size; hole = child ) {
        child = hole * 2 + 1;
        if( child < cur_size-1 && array[child]->expire > array[child+1]->expire ) {  // 右子節點較小
            child++;  // 將節點切換到右子節點
        }
        if( tmp->expire > array[child]->expire ) {  // 子樹的根節點值大於子節點值
            array[hole] = array[child];
        } else {  // tmp節點的值最小，符合
            break;
        }
    }
    array[hole] = tmp;  // 將最初的節點放到合適的位置
}

// 新增定時器，先放在陣列末尾，在進行上濾使其滿足最小堆
void TimeHeap::add_timer( HeapTimer* timer ) {
    if( !timer ) {
        return ;
    }

    if( cur_size >= capacity ) {
        resize();  // 空間不足，將堆空間擴大為原來的2倍
    }

    int hole = cur_size++;
    int parent = 0;

    // 由於新結點在最後，因此將其進行上濾，以符合最小堆
    for( ; hole > 0; hole = parent ) {
        parent = ( hole - 1 ) / 2;
        if( array[parent]->expire > timer->expire ) {
            array[hole] = array[parent];
        } else {
            break;
        }
    }
    array[hole] = timer;
}

// 刪除指定定時器
void TimeHeap::del_timer( HeapTimer* timer ) {
    if( !timer ) {
        return;
    }
    // 僅僅將回調函式置空，雖然節省刪除的開銷，但會造成陣列膨脹
    timer->cb_func = nullptr;
}

// 刪除堆頂定時器
void TimeHeap::pop_timer() {
    if( !cur_size ) {
        return;
    }
    if( array[0] ) {
        delete array[0];
        array[0] = array[--cur_size];
        percolate_down( 0 );  // 對新的根節點進行下濾
    }
}

// 從時間堆中尋找到時間的結點
void TimeHeap::tick() {
    HeapTimer* tmp = array[0];
    time_t cur = time( NULL );
    while( !cur_size ) {
        if( !tmp ) {
            break ;
        }
        if( tmp->expire > cur ) {  // 未到時間
            break;
        }
        if( array[0]->cb_func ) {
            array[0]->cb_func( array[0]->user_data );
        }
        pop_timer();
        tmp = array[0];
    }
}

// 空間不足時，將空間擴大為原來的2倍
void TimeHeap::resize() {
    HeapTimer** tmp = new HeapTimer*[ capacity * 2 ];
    for( int i = 0; i < 2 * capacity; i++ ) {
        tmp[i] = nullptr;
    }
    if( !tmp ) {
        throw std::exception();
    }
    capacity *= 2;
    for( int i = 0; i < cur_size; i++ ) {
        tmp[i] = array[i];
    }
    delete[] array;
    array = tmp;
}

#endif