d叉堆实现优先队列

d叉堆实现优先队列

时间复杂度 dlog（d,n)

#include <stdexcept>
#include <iostream>
class DForkHeapPriorityQueue {
private:
    int capacity;
    int *array;
    int d;
    int heap_size;
public:
    DForkHeapPriorityQueue(int capacity,int d);
    DForkHeapPriorityQueue(int* array,int length,int d);
    virtual ~DForkHeapPriorityQueue();
    void insert(int key);
    int extract_max();
    int get_heap_size();

private:
    void increase_key(int key,int index);
    void build_heap();
    void max_heapify(int parent_index);
    int parent(int index);
    int child(int parent_index,int child_index);
};

DForkHeapPriorityQueue::DForkHeapPriorityQueue(int capacity,int d):capacity(capacity),d(d){
    array = new int [capacity];
    heap_size = 0;
}
DForkHeapPriorityQueue::DForkHeapPriorityQueue(int* array,int length,int d):d(d)
{
    this->array = new int [length];
    for (int i = 0; i < length; ++i) {
        this->array[i] = array[i];
    }
    heap_size = length;
    capacity = heap_size;
    build_heap();
}
DForkHeapPriorityQueue::~DForkHeapPriorityQueue()
{
    if(array!= nullptr)
        delete [] array;
}
void DForkHeapPriorityQueue::insert(int key){
    if(heap_size >= capacity)
    {
        int* temp_array = new int[capacity*2];
        for (int i = 0; i < capacity; ++i) {
            temp_array[i] = array[i];
        }
        delete [] array;
        array = temp_array;
    }
    heap_size++;
    array[heap_size-1] = INT_MIN;
    increase_key(heap_size-1,key);
}
int DForkHeapPriorityQueue::extract_max(){
    if(heap_size<=0)
    {
        perror("array is empty");
        return -1;
    }
    int max = array[0];
    array[0] = array[heap_size-1];
    heap_size--;
    max_heapify(0);
    return max;
}

void DForkHeapPriorityQueue::increase_key(int key,int index){
    if(array[index] > key)
    {
        perror("new key is underflow");
        return;
    }
    array[index] = key;
    while (index > 0 && array[parent(index)] < key)
    {
        array[index] = array[parent(index)];
        array[parent(index)] = key;
        index = parent(index);
    }
}
void DForkHeapPriorityQueue::build_heap(){
    for (int i = heap_size/2; i >=0; i--) {
        max_heapify(i);
    }
}
void DForkHeapPriorityQueue::max_heapify(int parent_index){
    int largest = parent_index;
    int current_child_index = 0;
    while (current_child_index<d)
    {
        int index = child(parent_index,current_child_index);
        if(index >= heap_size) break;
        if(array[index] > array[largest])
            largest = index;
        current_child_index++;
    }
    if(largest != parent_index)
    {
        int temp = array[largest];
        array[largest] = array[parent_index];
        array[parent_index] = temp;
        max_heapify(largest);
    }
}
int DForkHeapPriorityQueue::parent(int index){
    return (index - 1) / d;
}
int DForkHeapPriorityQueue::child(int parent_index,int child_index){
   return parent_index * d + child_index + 1;
}
int DForkHeapPriorityQueue::get_heap_size(){
    return heap_size;
}