【数据结构】MinHeap 的实现

面试一个大厂，让我实现最小堆的的两个功能：

• insert：插入元素，保持最小堆特性
• pop：推出第一个最小的元素

首先，堆是一种二叉树结构，但经过了排序，最小的元素永远是根元素，且对所有子树都成立。

但是对于每一个树，其左右子节点的大小则并不一定是排序的，也就是说左子节点和右子节点谁大谁小不一定。且左右子节点的值可能等于根节点。

根据 [1] 和观摩其他大神写的最小堆，实现最小堆不需要显式的实现 Node，因为堆总是向左填充（维持排序），其数据结构一直被完好的维持。若使用显式节点实现会破坏结构也会影响性能。

实现如下

MInheapSource.h:

 

#pragma once
#ifndef MINHEAPSOURCE_H
#define MINHEAPSOURCE_H

template<class T> // 可使用多种数据类型作为模板
class MinHeap {
public:
    MinHeap(int maxSize);   // 构造空最小堆
    MinHeap(T* arr, int size);   // 从数组中构造堆
    MinHeap(MinHeap& m);    // 从其他最小堆构造
    ~MinHeap();

    // 节点位置计算
    inline int left(int index) { return 2 * index + 1; }
    inline int right(int index) { return 2 * index + 2; }
    inline int parent(int index) { return (index - 1) / 2; }

    // 返回目前MinHeap大小
    inline int size(){ return _currentSize + 1 ;}
    bool isEmpty();
    bool isFull();
    void insert(const T& t);
    bool pop(T& result);    // 推出第一个最小元素

    T* getMinHeap();
    // 显式数组
    void print();
private:
    T* _minheap = nullptr;  // 堆本体
    int _currentSize; // 目前大小
    int _maxSize;   // 最大容量
    void shiftDown(const int index, const int end); // 向下调整堆以维持堆的层级
    void shiftUp(int index); // 向上调整堆以维持堆的层级
};

#endif

 

MInheapSource.cpp:

#include "MinHeapSource.h"
#include <iostream>

template<class T>
MinHeap<T>::MinHeap(int maxSize) {
    _maxSize = maxSize;
    _minheap = new T[_maxSize];
    if (_minheap == nullptr) {
        std::cerr << "MinHeap Memory allocation failed" << std::endl;
        exit(-1);
    }
    _currentSize = 0;
}

template<class T>
MinHeap<T>::MinHeap(T* arr, int size) {
    _maxSize = size;
    _minheap = new T[_maxSize];
    if (_minheap == nullptr) {
        std::cerr << "MinHeap Memory allocation failed" << std::endl;
        exit(-1);
    }
    // 逐个赋值
    _currentSize = size;
    for (int i = 0; i < _currentSize; ++i) {
        _minheap[i] = arr[i];
    }

    // 利用下滑算法形成最小堆
    // NOTE: 以为curPos指向的时下标，所以要减2
    int curPos = (_currentSize - 2) / 2;
    while (curPos >= 0) {
        shiftDown(curPos, _currentSize - 1);
        --curPos;
    }
}

template<class T>
MinHeap<T>::MinHeap(MinHeap& m) {
    _minheap = new T[_maxSize]; // 申请新的空间
    if (_minheap == nullptr) {
        std::cerr << "MinHeap Memory allocation failed" << std::endl;
            exit(-1);
    }
    for (int i = 0; i < _maxSize; ++i)
        *_minheap[i] = *m._minheap[i];
    _currentSize = m._currentSize;
    _maxSize = m._maxSize;
}

template<class T>
MinHeap<T>::~MinHeap() {
    if(_minheap != nullptr)
        delete []_minheap;
}

template<class T>
bool MinHeap<T>::isEmpty() {
    return _currentSize == 0;
}

template<class T>
bool MinHeap<T>::isFull() {
    return _currentSize == _maxSize;
}

template<class T>
T* MinHeap<T>::getMinHeap() {
    return _minheap;
}

template<class T>
void MinHeap<T>::insert(const T& t) {
    if (isFull()) {
        std::cerr << "the MinHeap is full, can't insert more element" << std::endl;
        return;
    }
    _minheap[_currentSize] = t;
    shiftUp(_currentSize);    // 自下而上调整最小堆
    ++_currentSize;
}

template<class T>
bool MinHeap<T>::pop(T& result) {
    if (_currentSize > _maxSize) {
        std::cerr << "the MinHeap is empty, no element to pop" << std::endl;
        return false;
    }
    result = _minheap[0];
    // 将当前的第一个元素替换为最后一个元素，然后自上而下调整为最小堆
    _minheap[0] = _minheap[_currentSize - 1];
    _currentSize--;
    shiftDown(0, _currentSize - 1);  // 自上而下调整为最小堆
    return true;
}

// 自下而上调整最小堆（修复 insert）
template<class T>
void MinHeap<T>::shiftUp(int index) {
    if (isEmpty()) return;

    int current = index;
    int parentC = parent(current);
    // 若抵达顶点，返回
    if (current <= 0)    return;
    // 若父节点大于当前节点时，递归交换
    if (_minheap[parentC] > _minheap[current]) {
        int temp = _minheap[parentC];
        _minheap[parentC] = _minheap[current];
        _minheap[current] = temp;
        shiftUp(parentC);
    }
}

// 自上而下调整最小堆（修复 pop）
template<class T>
void MinHeap<T>::shiftDown(const int index, const int end) {
    if (isEmpty()) return;

    int current = index;    // 保留当前索引
    int leftC = left(current);

    // 若左子节点或右子节点超出范围，返回
    if (leftC > end)
        return;

    // 比较左右子节点（主要和左子节点作比较）
    if (leftC < end && _minheap[leftC] > _minheap[leftC + 1]) 
        ++leftC;

    // 若当现结点大于左子节点时，递归交换
    if (_minheap[current] > _minheap[leftC]) {
        int temp = _minheap[current];
        _minheap[index] = _minheap[leftC];
        _minheap[leftC] = temp;
        shiftDown(leftC, end);
    }
}

template<class T>
void MinHeap<T>::print() {
    for (int i = 0; i < _currentSize; ++i) {
        std::cout << _minheap[i] << "\t";
    }
    std::cout << std::endl;
}

 

主程序：

// MinHeap.cpp : This file contains the 'main' function. Program execution begins and ends there.
//
#include "MinHeapSource.h"
#include "MinHeapSource.cpp"    // include source file because the template class has to include definition explict in the main
#include <iostream>

using namespace std;

int main() {

    int a[] = { 9, 6, 5, 4, 3, 2, 1 };
    MinHeap<int> heap(a, 7);

    cout << "Init the heap" << endl;
    heap.print();

    int p;
    heap.pop(p);
    cout << "Pop smallest element: " << p << endl;
    heap.print();

    cout << "Insert 10" << endl;
    heap.insert(10);
    heap.print();

    return 0;
}

/*
运行结果：
Init the heap
1       3       2       4       6       9       5
Pop smallest element: 1
2       3       5       4       6       9
Insert 10
2       3       5       4       6       9       10
*/

 

注：

1）为什么要下滑和上滑（ShiftDown & ShiftUp）？

　　这主要是因为堆结构在插入（insert）和删除最小元素（pop）操作时会破坏堆的结构，所以需要下滑和上滑两个操作。下滑用于修复插入后堆元素的破坏，上滑用于修复删除最小元素时对堆元素的破坏。[3]

 

参考资料：

[1] 实现指引：https://www.coder.work/article/2752123

[2] 实现参考：https://blog.csdn.net/qq_37623612/article/details/88696924

[3] 为什么要ShiftDown & ShiftUp：https://mingshan.fun/2019/05/14/heap/