Починил удаление (много саут)

#include <iostream>
#include <vector>
#include <deque>

using namespace std;

enum heap_type
{
    heap_max = 0,
    heap_min = 1
};

class Heap
{
    std::vector<int> h;
    std::vector<int> ID_to_HeapIdx;
    int heap_size;
    int curr_ID;

public:
    Heap();
    void siftup(int sort_type, int ID, std::vector<int>& HeapIdx_to_ID);
    void siftdown(int sort_type, int ID, std::vector<int>& HeapIdx_to_ID);
    void add(int sort_type, int vertex, int ID, std::vector<int>& HeapIdx_to_ID);
    void delete_vertex(int sort_type, int ID, std::vector<int>& HeapIdx_to_ID);
    bool isempty();
    void out();
    int get_root();
};

Heap::Heap()
{
    std::vector<int> h;
    heap_size = 0;
    std::vector<int> ID_to_HeapIdx;
}

int Heap::get_root()
{
    if (heap_size > 0)
        return h[0];
    return -1;
}

bool Heap::isempty()
{
    if (heap_size == 0)
        return true;
    return false;
}

void Heap::siftup(int sort_type, int ID, std::vector<int>& HeapIdx_to_ID)
{
    int curr, parent, tmp;
    curr = heap_size - 1;
    parent = (curr - 1);
    for (int i = 0; i < HeapIdx_to_ID.size(); i++)
        for (int i = 0; i < ID_to_HeapIdx.size(); i++)
            while (parent >= 0 && curr > 0)
            {

                if (sort_type == heap_max & h[parent] < h[curr])
                {

                    int buff = h[curr];
                    h[curr] = h[parent];
                    h[parent] = buff;

                    tmp = HeapIdx_to_ID[parent];
                    HeapIdx_to_ID[parent] = HeapIdx_to_ID[curr];
                    HeapIdx_to_ID[curr] = tmp;


                    tmp = ID_to_HeapIdx[HeapIdx_to_ID[parent]];
                    ID_to_HeapIdx[HeapIdx_to_ID[parent]] = ID_to_HeapIdx[HeapIdx_to_ID[curr]];
                    ID_to_HeapIdx[HeapIdx_to_ID[curr]] = tmp;
                }

                if (sort_type == heap_min & h[parent] > h[curr])
                {

                    int buff = h[curr];
                    h[curr] = h[parent];
                    h[parent] = buff;

                    tmp = HeapIdx_to_ID[parent];
                    HeapIdx_to_ID[parent] = HeapIdx_to_ID[curr];
                    HeapIdx_to_ID[curr] = tmp;


                    tmp = ID_to_HeapIdx[HeapIdx_to_ID[parent]];
                    ID_to_HeapIdx[HeapIdx_to_ID[parent]] = ID_to_HeapIdx[HeapIdx_to_ID[curr]];
                    ID_to_HeapIdx[HeapIdx_to_ID[curr]] = tmp;
                }
                curr = parent;
                parent = (curr - 1);
            }
}

void Heap::add(int sort_type, int vertex, int ID, std::vector<int>& HeapIdx_to_ID)
{

    h.push_back(vertex);
    ID_to_HeapIdx.push_back(heap_size);
    HeapIdx_to_ID.push_back(ID);

    cout << "Только что добавили элемент в конец кучи" <<  endl;
    if (sort_type == heap_max)
        cout << "ID_to_Heap1Idx[ID]= " ;
    else
        cout << "ID_to_Heap2Idx[ID]= " ;
    for (int j=0;j < ID_to_HeapIdx.size(); j++)
        cout << ID_to_HeapIdx[j] << " ";
    cout << endl;
    cout << endl;

    if (sort_type == heap_max)
        cout << "HeapIdx1_to_ID[ID]= " ;
    else
        cout << "HeapIdx2_to_ID[ID]= " ;
    for (int j=0;j < HeapIdx_to_ID.size(); j++)
        cout << HeapIdx_to_ID[j] << " ";
    cout << endl;
    cout << endl;

    heap_size++;
    siftup(sort_type, ID, HeapIdx_to_ID);

    cout << "После сифтапа" << endl;
    cout << "Только что добавили элемент в конец кучи" <<  endl;
    if (sort_type == heap_max)
        cout << "ID_to_Heap1Idx[ID]= " ;
    else
        cout << "ID_to_Heap2Idx[ID]= " ;
    for (int j=0;j < ID_to_HeapIdx.size(); j++)
        cout << ID_to_HeapIdx[j] << " ";
    cout << endl;
    cout << endl;

    if (sort_type == heap_max)
        cout << "HeapIdx1_to_ID[ID]= " ;
    else
        cout << "HeapIdx2_to_ID[ID]= " ;
    for (int j=0;j < HeapIdx_to_ID.size(); j++)
        cout << HeapIdx_to_ID[j] << " ";
    cout << endl;
    cout << endl;

}

void Heap::siftdown(int sort_type, int ID, std::vector<int>& HeapIdx_to_ID)
{
    int parent, max_child, min_child, tmp, buff;

    int curr = ID_to_HeapIdx[ID];
    ID_to_HeapIdx[ID] = -100;
    int child_l = 2 * curr + 1;
    int child_r = 2 * curr + 2;


    if (h[child_r] < h[child_l])
    {
        max_child = child_l;
        min_child = child_r;
    }
    else
    {
        max_child = child_r;
        min_child = child_l;
    }
    while (child_l < heap_size)
    {


        if (sort_type == heap_max)
        {
            if (child_l == heap_size - 1)
                max_child = child_l;

            else if (h[child_r] < h[child_l])
                max_child = child_l;
            else
                max_child = child_r;
        }

        if (sort_type == heap_min)
        {
            if (child_l == heap_size - 1)
                min_child = child_l;
            else if (h[child_r] < h[child_l])
                min_child = child_r;
            else
                min_child = child_l;
        }

        if (sort_type == heap_max & h[curr] < h[max_child])
        {

            buff = h[curr];
            h[curr] = h[max_child];
            h[max_child] = buff;

            tmp = HeapIdx_to_ID[max_child];
            HeapIdx_to_ID[max_child] = HeapIdx_to_ID[curr];
            HeapIdx_to_ID[curr] = tmp;

            tmp = ID_to_HeapIdx[HeapIdx_to_ID[max_child]];
            ID_to_HeapIdx[HeapIdx_to_ID[max_child]] = ID_to_HeapIdx[HeapIdx_to_ID[curr]];
            ID_to_HeapIdx[HeapIdx_to_ID[curr]] = tmp;
        }

        if (sort_type == heap_min & h[curr] > h[max_child])
        {

            buff = h[curr];
            h[curr] = h[max_child];
            h[max_child] = buff;

            tmp = HeapIdx_to_ID[max_child];
            HeapIdx_to_ID[max_child] = HeapIdx_to_ID[curr];
            HeapIdx_to_ID[curr] = tmp;

            tmp = ID_to_HeapIdx[HeapIdx_to_ID[max_child]];
            ID_to_HeapIdx[HeapIdx_to_ID[max_child]] = ID_to_HeapIdx[HeapIdx_to_ID[curr]];
            ID_to_HeapIdx[HeapIdx_to_ID[curr]] = tmp;
        }
        curr = max_child;
        child_l = 2 * curr + 1;
        child_r = 2 * curr + 2;
    }
}


void Heap::delete_vertex(int sort_type, int ID, std::vector<int>& HeapIdx_to_ID)
{
    int pos = ID_to_HeapIdx[ID];

    cout << "поступил запрос на удаление по ID= " << ID << "pos in heap = " << pos << endl;
    cout << "h[pos]" << h[pos] << endl;

    cout << "До каких либо действий" <<  endl;
    if (sort_type == heap_max)
        cout << "ID_to_Heap1Idx[ID]= " ;
    else
        cout << "ID_to_Heap2Idx[ID]= " ;
    for (int j=0;j < ID_to_HeapIdx.size(); j++)
        cout << ID_to_HeapIdx[j] << " ";
    cout << endl;
    cout << endl;

    if (sort_type == heap_max)
        cout << "HeapIdx1_to_ID[ID]= " ;
    else
        cout << "HeapIdx2_to_ID[ID]= " ;
    for (int j=0;j < HeapIdx_to_ID.size(); j++)
        cout << HeapIdx_to_ID[j] << " ";
    cout << endl;
    cout << endl;

    h[pos] = h[heap_size - 1];
    h.pop_back();
    heap_size--;
    //ID_to_HeapIdx[HeapIdx_to_ID[pos]] = -100; //Беру айди элемента pos и теперь Id[id] = -100;
    int id_last_el = HeapIdx_to_ID[heap_size];
    //cout << "id_last_el=" << id_last_el << endl;
    HeapIdx_to_ID[pos] = id_last_el;
    HeapIdx_to_ID[heap_size] = -100;
    ID_to_HeapIdx[id_last_el] = pos; //Дают айди послед эл, а он уже на Pos
    //ID_to_HeapIdx[ID] = -100;

    cout << "До сифтдауна" <<  endl;
    if (sort_type == heap_max)
        cout << "ID_to_Heap1Idx[ID]= " ;
    else
        cout << "ID_to_Heap2Idx[ID]= " ;
    for (int j=0;j < ID_to_HeapIdx.size(); j++)
        cout << ID_to_HeapIdx[j] << " ";
    cout << endl;
    cout << endl;

    if (sort_type == heap_max)
        cout << "HeapIdx1_to_ID[ID]= " ;
    else
        cout << "HeapIdx2_to_ID[ID]= " ;
    for (int j=0;j < HeapIdx_to_ID.size(); j++)
        cout << HeapIdx_to_ID[j] << " ";
    cout << endl;
    cout << endl;

    siftdown(sort_type, ID, HeapIdx_to_ID);
    cout << "ID_to_HeapIdx[HeapIdx_to_ID[pos]] = " << ID_to_HeapIdx[HeapIdx_to_ID[pos]] << endl;


    cout << "POSLE" <<  endl;
    if (sort_type == heap_max)
        cout << "ID_to_Heap1Idx[ID]= " ;
    else
        cout << "ID_to_Heap2Idx[ID]= " ;
    for (int j=0;j < ID_to_HeapIdx.size(); j++)
        cout << ID_to_HeapIdx[j] << " ";
    cout << endl;
    cout << endl;

    if (sort_type == heap_max)
        cout << "HeapIdx1_to_ID[ID]= " ;
    else
        cout << "HeapIdx2_to_ID[ID]= " ;
    for (int j=0;j < HeapIdx_to_ID.size(); j++)
        cout << HeapIdx_to_ID[j] << " ";
    cout << endl;
    cout << endl;
}


void Heap::out(void)
{

    for (int i = 0; i < heap_size; i++)
    {
        cout << h[i] << " ";
    }
    cout << endl;
}


int main()
{
    Heap heap;
    std::vector<int> HeapIdx_to_ID;
    heap.add(heap_max,1,0,HeapIdx_to_ID);  //1
    heap.out();
    cout << "----------------------------" << endl << endl;
    heap.add(heap_max,4,1,HeapIdx_to_ID);  //4 1
    heap.out();
    cout << "----------------------------" << endl << endl;
    heap.add(heap_max,5,2,HeapIdx_to_ID);  //5 4 1
    heap.out();
    cout << "----------------------------" << endl << endl;
    heap.add(heap_max,2,3,HeapIdx_to_ID);  //5(2) 4(1) 2(3) 1(0)   , ID = 3 1 0 2 - где лежит .. айдишник
    heap.out();
    cout << "----------------------------" << endl << endl;
    heap.delete_vertex(heap_max,2,HeapIdx_to_ID); //4(1) 1(0) 2(3) -100   , ID = 1 0 -100 2   (WA 4 1 2)
    heap.out();

    cout << "----------------------------" << endl << endl;
    heap.delete_vertex(heap_max,3,HeapIdx_to_ID); //4 1
    heap.out();
    cout << "----------------------------" << endl << endl;
    heap.delete_vertex(heap_max,1,HeapIdx_to_ID); //1
    heap.out();
    cout << "----------------------------" << endl << endl;
    heap.delete_vertex(heap_max,0,HeapIdx_to_ID); //
    heap.out();
    cout << "----------------------------" << endl << endl;



return 0;
}