试图打印出最小堆最后一层的元素

问题描述

我正在尝试在最小堆中打印最后一个级别。我以为我有有效的代码，但其中一个测试用例失败了。就测试用例而言，我只能访问输出不匹配的方式。

这是我的代码：

#include "MinHeap.h"
#include <math.h>

using std::log2;

vector<int> lastLevel(MinHeap & heap)
{
        // Your code here
        vector<int> leaves;
        int capacity = pow(2,log2(heap.elements.size()) + 1) - 1;
        for (unsigned leaf = capacity / 2; leaf < heap.elements.size(); leaf++) {
                leaves.push_back(heap.elements[leaf]);
        }
        return leaves;
}

这是伴随它的 MinHeap 类：

#include "MinHeap.h"

MinHeap::MinHeap(const vector<int> & vector)
{
    int inf = numeric_limits<int>::min();
    elements.push_back(inf);
    elements.insert(elements.end(),vector.begin(),vector.end());
    buildHeap();
}

MinHeap::MinHeap()
{
    int inf = numeric_limits<int>::min();
    elements.push_back(inf);
}

void MinHeap::buildHeap()
{
    std::sort(elements.begin() + 1,elements.end());
}

void MinHeap::heapifyDown(int index)
{
    int length = elements.size();
    int leftChildIndex = 2 * index;
    int rightChildIndex = 2 * index + 1;

    if (leftChildIndex >= length)
        return; // index is a leaf

    int minIndex = index;

    if (elements[index] > elements[leftChildIndex]) {
        minIndex = leftChildIndex;
    }

    if ((rightChildIndex < length)
        && (elements[minIndex] > elements[rightChildIndex])) {
        minIndex = rightChildIndex;
    }

    if (minIndex != index) {
        // need to swap
        int temp = elements[index];
        elements[index] = elements[minIndex];
        elements[minIndex] = temp;
        heapifyDown(minIndex);
    }
}

void MinHeap::heapifyUp(int index)
{
    if (index < 2)
        return;

    int parentIndex = index / 2;

    if (elements[parentIndex] > elements[index]) {
        int temp = elements[parentIndex];
        elements[parentIndex] = elements[index];
        elements[index] = temp;
        heapifyUp(parentIndex);
    }
}

void MinHeap::insert(int newValue)
{
    int length = elements.size();
    elements.push_back(newValue);
    heapifyUp(length);
}

int MinHeap::peek() const
{
    return elements.at(1);
}

int MinHeap::pop()
{
    int length = elements.size();
    int p = -1;

    if (length > 1) {
        p = elements[1];
        elements[1] = elements[length - 1];
        elements.pop_back();
        heapifyDown(1);
    }

    return p;
}

void MinHeap::print() const
{
    if (elements.size() > 1) {
        int length = elements.size();
        cout << "[";
        for (int i = 1; i < length - 1; i++) {
            cout << elements[i] << ",";
        }
        cout << elements[elements.size() - 1] << "]" << endl;
    } else {
        cout << "[ ]" << endl;
    }
}

这是我得到的输出，显示其中一个测试用例失败：

tests.cpp:31: FAILED:
  REQUIRE( s_lastLevel(h) == lastLevel(h) )
with expansion:
  { 1804289383 (0x6b8b4567),1681692777 (0x643c9869) }
  ==
  { 1681692777 (0x643c9869) }

===============================================================================
test cases: 1 | 1 failed
assertions: 3 | 2 passed | 1 failed

我不确定为什么我最初的方法失败了。非常感谢您的帮助。

解决方法

暂无找到可以解决该程序问题的有效方法，小编努力寻找整理中！

如果你已经找到好的解决方法，欢迎将解决方案带上本链接一起发送给小编。

小编邮箱:dio#foxmail.com (将#修改为@）