D-堆的C++实现

所谓D-堆就是以一维数组形式表示的以完全D叉树的形式组织的堆结构，实际上就是D叉堆
它与二叉堆的一个显著的不同就是寻找节点的父节点和父节点第$i$个子节点($1<=i<=D$)所用的算法，在D叉堆中节点$i(i>1)$的父节点为$\left[\frac{i-2}{D}\right]+1$,节点$p$的第$q$($1<=q<=D$)个节点为$D(p-1)+q+1$
其余操作均和二叉堆类似，实现也较为容易，见以下代码

#include <iostream>
#include <vector>
#include <random>
#include <ctime>
#include <deque>
using namespace std;

template <typename T>
class D_Heap
{
public:
    bool isEmpty() { return heap.empty(); }
    size_t getSize() { return heap.size(); };
    bool removeMinValue(T &key);
    void insert(const T& key);
    bool changeValue(const T& key, size_t index);
    bool Delete(size_t index);
    bool isD_Heap();
    T& _at(size_t index)
    {
        if (index >= heap.size())
            return NullValue;
        return heap[index];
    }
    D_Heap(const vector<T>& input, size_t D, const T&Min);
private:
    void siftup(size_t start);
    void siftdown(size_t start);
    T NullValue;
    T MinValue;
    vector<T> heap;
    size_t D;
};
template <typename T>
bool D_Heap<T>::isD_Heap()
{
    deque<size_t> q;
    q.push_back(1);
    size_t n = 1;
    while (q.empty() == false)
    {
        size_t num = 0;
        for (size_t run = 1; run <= n; ++run)
        {
            size_t cur = q.front();
            q.pop_front();
            size_t p = D * (cur - 1) + 2;
            size_t end = p + D - 1;
            while (p <= end && p <= heap.size())
            {
                if (heap[p - 1] < heap[cur - 1])
                {
                    cout << "错误" << p << "节点关键码小于其父节点" << cur << "的关键码,非D堆" << endl;
                    return false;
                }
                q.push_back(p);
                ++num;
                ++p;
            }
        }
        n = num;
    }
    return true;
}

template <typename T>
D_Heap<T>::D_Heap(const vector<T>& input, size_t D, const T& Min):D(D), MinValue(Min)
{
    if (D <= 1)
    {
        cout << "D(order) invaild" << endl;
        exit(-1);
    }
    for (auto p = input.cbegin(); p != input.cend(); ++p)
    {
        if (*p < MinValue)
        {
            cout << "Error,invaild value" << endl;
            exit(-1);
        }
    }
    heap.insert(heap.end(), input.begin(), input.end());
    if (input.size() <= 1)
        return;
    for (size_t run = (heap.size() - 2) / D + 1; run > 0; --run)
    {
        siftdown(run);
    }
}

template <typename T>
bool D_Heap<T>::Delete(size_t index)
{
    if (index >= heap.size())
    {
        cout << "Error,invaild index" << endl;
        return false;
    }
    changeValue(MinValue, index);
    removeMinValue(MinValue);
    return true;
}

template <typename T>
bool D_Heap<T>::changeValue(const T& key, size_t index)
{
    if (key < MinValue)
    {
        cout << "Error,invaild value" << endl;
        return false;
    }

    if (index >= heap.size())
    {
        cout << "Error,invaild index" << endl;
        return false;
    }

    if (heap[index] == key)
        return true;

    if (key < heap[index])
    {
        heap[index] = key;
        siftup(index + 1);
    }
    else
    {
        heap[index] = key;
        siftdown(index + 1);
    }
    return true;
}

template <typename T> 
void D_Heap<T>::insert(const T& key)
{
    heap.push_back(key);
    siftup(heap.size());
}

template <typename T>
bool D_Heap<T>::removeMinValue(T& key)
{
    if (heap.empty())
        return false;
    if (heap.size() == 1)
    {
        key = heap[0];
        heap.pop_back();
        return true;
    }
    key = heap[0];
    heap[0] = heap.back();
    heap.pop_back();
    siftdown(1);
    return true;
}

template <typename T>
void D_Heap<T>::siftup(size_t start)
{
    if (start == 1)
        return;
    T temp = heap[start - 1];
    size_t father = (start - 2) / D + 1;
    while (true)
    {
        if (temp >= heap[father - 1])
            break;
        heap[start - 1] = heap[father - 1];
        start = father;
        if (father == 1)
            break;
        father = (father - 2) / D + 1;
    }
    heap[start - 1] = temp;
}

template <typename T>
void D_Heap<T>::siftdown(size_t start)
{
    size_t sub = D*(start - 1) + 2;
    T temp = heap[start - 1];
    while (sub <= heap.size())
    {
        {
            size_t right_end = sub + D;
            size_t min_pos = sub;
            T t = heap[sub - 1];
            for (++sub; sub <= heap.size() && sub < right_end; ++sub)
            {
                if (heap[sub - 1] < t)
                {
                    t = heap[sub - 1];
                    min_pos = sub;
                }
            }
            sub = min_pos;
        }

        if (temp <= heap[sub - 1])
            break;
        heap[start - 1] = heap[sub - 1];
        start = sub;
        sub = D * (sub - 1) + 2;
    }
    heap[start - 1] = temp;
}
int main()
{
    const int N = 10000;
    vector<int> input(N);
    for (int j = 0; j < N; ++j)
    {
        input[j] = j + 1;
    }
    shuffle(input.begin(), input.end(), default_random_engine());
    D_Heap<int> obj(input, 4, -200000);

    if (obj.isD_Heap())
    {
        cout << "初始化后的D堆性质维持" << endl;
    }
    else
    {
        cout << "初始化后的D堆性质破坏" << endl;
        exit(-1);
    }

    /*for (; obj.isEmpty() == false;)
    {
        size_t j = rand() % obj.getSize() + 1;
        cout << "删除下标" << j << "元素" << endl;
        obj.Delete(j - 1);
        if (obj.isD_Heap())
        {
            cout << "D堆性质维持" << endl;
        }
        else
        {
            cout << "D堆性质破坏!" << endl;
            exit(-1);
        }
    }*/

    for (const auto& run : input)
    {
        cout << "插入" << run << endl;
        obj.insert(run);
        if (obj.isD_Heap())
        {
            cout << "D堆性质维持" << endl;
        }
        else
        {
            cout << "D堆性质破坏" << endl;
            exit(-1);
        }
    }

    while (obj.isEmpty() == false)
    {
        int key;
        obj.removeMinValue(key);
        cout << "移除最小值" << key << endl;
        if (obj.isD_Heap()) 
        {
            cout << "D堆性质维持" << endl;
        }
        else
        {
            cout << "D堆性质破坏" << endl;
            exit(-1);
        }
    }
    /*for (size_t i = 1; i <= N; ++i)
    {
        size_t j = rand() % obj.getSize() + 1;
        for (int run = -20; run <= 20; ++run)
        {
            cout << "将下标" << j << "元素" << "增加" << run << endl;
            obj.changeValue(obj._at(j - 1) + run, j - 1);
            if (obj.isD_Heap())
            {
                cout << "增加后D堆性质维持" << endl;
            }
            else
            {
                cout << "增加后D堆性质破坏!" << endl;
                exit(-1);
            }
            obj.changeValue(obj._at(j - 1) - run, j - 1);
            if (obj.isD_Heap())
            {
                cout << "恢复后D堆性质维持" << endl;
            }
            else
            {
                cout << "恢复后D堆性质破坏!" << endl;
                exit(-1);
            }
        }
    }*/

    return 0;
}