malloc.c：2379：sysmalloc：断言...失败

如何解决malloc.c：2379：sysmalloc：断言...失败

我目前正在编写一个使用Heap类的程序，以在数组中查找数组的一部分（部分大小为k）的最大值，该最大值在数组中移动，直到结束。它粉碎了数据集： 3 1 2 3 1个 带有错误：malloc.c：2379：sysmalloc：断言`（old_top == initial_top（av）&& old_size == 0）|| （（（无符号长）（old_size）> =最小大小&& prev_inuse（old_top）&&（（无符号长）old_end＆（页面大小-1））== 0）'失败。 当尝试删除temp.value变量时，它会崩溃。如果我将其冷却，一切都会很好

这是我的代码：

#include <iostream>
#include <cstring>
#include <cassert>

#define DEFAULT_GROW 2

template<class T>
class IsLess {
public:
    bool operator()(const T& lhs,const T& rhs) const {
        return lhs < rhs;
    }
};

template<class T>
struct Node {
    T value;
    size_t index;
};


template <class T,class H = IsLess<T>>
class Heap {
public:
    Heap();
    Heap(const T* arr,size_t dataSize,H func = IsLess<T>());
    Heap(const Heap&) = delete;
    Heap(Heap&&) = delete;
    Heap operator = (const Heap&) = delete;
    Heap operator = (Heap&&) = delete;
    ~Heap();
    bool IsEmpty();
    void Insert(const T &k);
    Node<T> ExtractMax();
    Node<T> ExtractMaxByIndex(const size_t &i,const size_t &k);
    void InsertNode(const Node<T> &);

private:
    void Grow();
    void BuildHeap();
    void SiftDown(const int &i);
    void SiftUp(int i);
    size_t capacity;
    size_t size;
    Node<T>* data;
    H comparator;
};

template<class T,class H>
Heap<T,H>::Heap():
capacity(0),size(0),data(nullptr),comparator(IsLess<T>())
{}

template<class T,H>::Heap(const T* arr,H func) {
    assert(arr != nullptr);
    assert(dataSize > 0);
    data = new Node<T>[dataSize];
    capacity = dataSize;
    size = dataSize;
    comparator = func;
    // std::memcpy(data->value,arr,dataSize * sizeof(T) - 1);
    for (size_t i = 0; i < dataSize; ++i) {
        data[i].value = arr[i];
        data[i].index = i;
    }
    BuildHeap();
}

template<class T,H>::~Heap() {
    delete[] data;
}

template<class T,class H>
void Heap<T,H>::Grow() {
    if (capacity == 0) {
        data = new Node<T>[++capacity];
        return;
    }
    if (size < capacity) {
        return;
    }
    capacity *= DEFAULT_GROW;
    Node<T> *buf = new Node<T>[capacity];
    std::memcpy(buf,data,sizeof(Node<T>) * size - 1);
    delete[] data;
    data = buf;
}

template<class T,H>::SiftDown(const int &i) {
    size_t leftChild = i * 2 + 1;
    size_t rightChild = i * 2 + 2;
    size_t largest = i;
    if(leftChild < size
    && comparator(data[largest].value,data[leftChild].value)) {
        largest = leftChild;
    }
    if(rightChild < size
    && comparator(data[largest].value,data[rightChild].value)) {
        largest = rightChild;
    }
    if(largest != i) {
        std::swap(data[i],data[largest]);
        SiftDown(largest);
    }
}

template<class T,H>::SiftUp(int i) {
    while(i > 0) {
        int parent = (i - 1) / 2;
        if(comparator(data[i].value,data[parent].value)) {
            return;
        }
        std::swap(data[i],data[parent]);
        i = parent;
    }
}

template<class T,H>::BuildHeap() {
    for (int i = size / 2 - 1 ; i >= 0 ; --i) {
        SiftDown(i);
    }
}

template<class T,class H>
bool Heap<T,H>::IsEmpty() {
    return size == 0;
}

template<class T,H>::Insert(const T &k) {
    if (IsEmpty() || size == capacity) {
        Grow();
    }
    data[size].value = k;
    data[size].index = size;
    SiftUp(size++);
}

template<class T,class H>
Node<T> Heap<T,H>::ExtractMax() {
    assert(!IsEmpty());
    Node<T> result = data[0];
    data[0] = data[--size];
    if (!IsEmpty()) {
        SiftDown(0);
    }
    return result;
}

template<class T,H>::InsertNode(const Node<T> &node) {
    if (IsEmpty() || size == capacity) {
        Grow();
    }
    data[size] = node;
    SiftUp(size++);
}

template<class T,H>::ExtractMaxByIndex(const size_t &i,const size_t &k) {
    assert(!IsEmpty());
    Node<T> result = {0,i + k + 1}; //  чтобы условие не выполнилось с 1 раза
    Node<T> *extracted = new Node<T>[k];
    size_t extractedindex = 0;
    while(result.index < i || result.index > i + k - 1) {
        result = ExtractMax();
        extracted[extractedindex++] = result;
    }
    for (size_t j = 0 ; j < extractedindex ; ++j) {
        InsertNode(extracted[j]);
    }
    delete [] extracted;
    return result;
}

void Answer (unsigned int *arr,const size_t &n,const size_t &i,const size_t &k) {
    assert(arr != nullptr);
    Heap<unsigned> heap(arr,n);
    //size_t resSize = n - k + 1;

    Node<unsigned int> temp = heap.ExtractMaxByIndex(i,k);
    std::cout << temp.value << " ";  // This line causes the misstake
}

int main() {
    size_t n = 0;
    std::cin >> n;
    unsigned int *arr = new unsigned int[n];
    for (size_t i = 0; i < n; ++i) {
        std::cin >> arr[i];
    }
    size_t k = 0;
    std::cin >> k;
    for (size_t i = 0 ; i < 1 ; ++i) {
        Answer(arr,n,i,k);
    }
    delete[] arr;
    return 0;
}

Input: 
3
1 2 3
1

Output:
1 2 3