C++最小堆

#include <iostream>

class MinHeap
{
private:
    int _max;
    int _count;
    int *_ptr;

public:
    explicit MinHeap(int number)
    {
        _max = number;
        _count = 0;
        _ptr = new int(_max);
    }
    ~MinHeap()
    {
        if (_ptr)
        {

            delete[] _ptr;
            _ptr = nullptr;
        }
    }

    void push(int number)
    {
        if (_count >= _max)
        {
            return;
        }
        _ptr[_count] = number;
        int j = _count;
        while (j > 0)
        {
            int i = (j - 1) / 2; // 计算父节点位置，调整后的数组是从根节点开始，从上到下，从左到右
            if (_ptr[i] <= _ptr[j])
                break;

            std::swap(_ptr[i], _ptr[j]); // 交换值
            j = i;                       // 当前操作节点
        }
        _count++;
    }
    void pop()
    {
        if (_count < 1)
        {
            return;
        }
        _count--;
        int i = 0, j = 0, last = _count - 1;
        _ptr[i] = _ptr[_count]; // 交换最后一个和根节点值
        while (j < last)
        {
            j = 2 * i + 1;
            // 左节点大于右节点
            if (j < last && _ptr[j] > _ptr[j + 1])
                j++;

            if (_ptr[i] < _ptr[j])
                break;

            std::swap(_ptr[i], _ptr[j]); // 交换
            i = j;
        }
    }
    int count() { return _count; }
    int *data() { return _ptr; }
};

int main(int argc, char const *argv[])
{
    MinHeap myheap(256);
    int sample[] = {1};
    for (int i = 0; i < sizeof(sample) / sizeof(int); i++)
    {
        myheap.push(sample[i]);
        for (int k = 0; k < myheap.count(); k++)
        {
            printf("%d ", myheap.data()[k]);
        }
        printf("\n-------------------------\n");
    }
    myheap.pop();
    for (int k = 0; k < myheap.count(); k++)
    {
        printf("%d ", myheap.data()[k]);
    }
    printf("\n-------------------------\n");
    return 0;
}