Перепиши программу для минимальной кучи. Программа: #include <iostream> // для вывода результатов


template<typename T>
class Heap {
private:
    T* heap; // массив для хранения узлов кучи
    int size;  // размер кучи
public:
    Heap(); // конструктор по умолчанию
    void insert(T value); // добавить узел в кучу
    bool search(T value); // найти узел в куче
    bool remove(T value); // удалить узел из кучи
    void heapSort(); // сортировка кучи
    void print(); // вывод текущего состояния кучи
    ~Heap(); // деструктор
};

template<typename T>
Heap<T>::Heap() {
    heap = new T[100]; // создаем массив из 100 элементов
    size = 0; // инициализируем размер кучи
}

template<typename T>
Heap<T>::~Heap() {
    delete[] heap; // освобождаем память, выделенную для массива
}

template<typename T>
void Heap<T>::insert(T value) {
    int index = size; // индекс нового узла равен текущему размеру кучи
    heap[index] = value; // добавляем новый узел в массив

    size++; // увеличиваем размер кучи

    // выполняем восстановление свойства кучи (например, с помощью просеивания вверх)
    while (index > 0 && heap[(index - 1) / 2] < heap[index]) {
        std::swap(heap[(index - 1) / 2], heap[index]);
        index = (index - 1) / 2;
    }
}

template<typename T>
bool Heap<T>::search(T value) {
    for (int i = 0; i < size; i++) {
        if (heap[i] == value) {
            return true; // значение найдено в куче
        }
    }

    return false; // значение не найдено
}

template<typename T>
bool Heap<T>::remove(T value) {
    for (int i = 0; i < size; i++) {
        if (heap[i] == value) {
            // перемещаем последний узел вместо удаляемого
            heap[i] = heap[size - 1];

            size--; // уменьшаем размер кучи

            // выполняем восстановление свойства кучи (например, с помощью просеивания вниз)
            while (true) {
                int left = 2 * i + 1;
                int right = 2 * i + 2;

                int largest = i;

                if (left < size && heap[left] > heap[largest]) {
                    largest = left;
                }

                if (right < size && heap[right] > heap[largest]) {
                    largest = right;
                }

                if (largest != i) {
                    std::swap(heap[i], heap[largest]);
                    i = largest;
                }
                else {
                    break;
                }
            }

            return true; // узел удален из кучи
        }
    }

    return false; // узел не найден
}

template<typename T>
void Heap<T>::print() {
    for (int i = 0; i < size; i++) {
        std::cout << heap[i] << " ";
    }

    std::cout << std::endl;
}

template<typename T>
void Heap<T>::heapSort() {
    // Построение кучи
    for (int i = size / 2 - 1; i >= 0; i–) {
        int parent = i;
        while (true) {
            int leftChild = 2 * parent + 1;
            if (leftChild >= size) {
                break;
            }
            int maxChild = leftChild;
            if (leftChild + 1 < size && heap[leftChild + 1] > heap[leftChild]) {
                maxChild = leftChild + 1;
            }
            if (heap[parent] >= heap[maxChild]) {
                break;
            }
            std::swap(heap[parent], heap[maxChild]);
            parent = maxChild;
        }
    }

    // Сортировка кучи по возрастанию
    for (int i = size - 1; i > 0; i–) {
        std::swap(heap[0], heap[i]);
        int parent = 0;
        while (true) {
            int leftChild = 2 * parent + 1;
            if (leftChild >= i) {
                break;
            }
            int maxChild = leftChild;
            if (leftChild + 1 < i && heap[leftChild + 1] > heap[leftChild]) {
                maxChild = leftChild + 1;
            }
            if (heap[parent] >= heap[maxChild]) {
                break;
            }
            std::swap(heap[parent], heap[maxChild]);
            parent = maxChild;
        }
    }
}

int main() {
    Heap<std::string> heap;

    heap.insert("s");
    heap.insert("sas");
    heap.insert("sasas");
    heap.insert("b");

    heap.print(); // выводит

    std::cout << heap.search("sas") << std::endl; // выводит: 1 (значение 4 найдено)
    std::cout << heap.search("bv") << std::endl; // выводит: 0 (значение 8 не найдено)

    std::cout << heap.remove("a") << std::endl;
    std::cout << heap.remove("s") << std::endl;
    heap.print(); // выводит

    return 0;
}