data structure | heap

#include <iostream>
#include <string.h>
using namespace std;

template <class T>
class Heap {
public:
    Heap():n(0), capacity(100) {
        this->arr = new T[capacity];
    }

    ~Heap() {
        delete[] arr;
    }

    void insert(T v) {
        if (n >= capacity) {
            T* tmp = new T[capacity << 1];
            memcpy(tmp, arr, sizeof(T) * capacity);
            capacity <<= 1;
        }
        arr[n++] = v;
        shiftUp(n - 1);
    }

    void del(int index) {
        if (index < 0 || index >= n) return;
        swap(arr[index], arr[n - 1]);
        shiftDown(index, --n);
    }

    void shiftDown(int st, int ed) {
        T tmp = arr[st];
        while (st < ed) {
            int next = -1;
            int left = st * 2 + 1; // left child node 
            if (left < ed) next = left;
            else break;
            int right = st * 2 + 2;
            if (right < ed && arr[right] < arr[next]) next = right;
            if (arr[next] < arr[st]) {
                arr[st] = arr[next];
                st = next;
            } else break;
        }
        arr[st] = tmp;
    }

    void shiftUp(int ed) {
        T tmp = arr[ed];
        while (ed > 0) {
            int parent = (ed - 1) / 2;
            if (arr[ed] < arr[parent]) {
                arr[ed] = arr[parent];
                ed = parent;
            } else break;
        }
        arr[ed] = tmp;
    }

    void sort() {
        for (int j = n - 1; j >= 1; --j) {
            swap(arr[0], arr[j]);
            shiftDown(0, j); // here should be j
        }
    }

    void print() const {
        for (int i = 0; i < n; ++i) {
            cout << arr[i] << " ";
        }
        cout << endl;
    }

    T get(int pos) {
        return arr[pos];
    }

    void update(int pos, int v) {
        if (pos < 0 || pos >= n) return;
        if (arr[pos] < v) {
            arr[pos] = v;
            shiftDown(pos, n);
        } else {
            shiftUp(pos);
        }
    }
    void increase(int pos, int v) {
        if (pos < 0 || pos >= n) return;
        arr[pos] = arr[pos] + v;
        shiftDown(pos, n);
    }

    void decrease(int pos, int v) {
        if (pos < 0 || pos >= n) return;
        arr[pos] = arr[pos] - v;
        shiftUp(pos);
    }

    bool empty() const {
        return n <= 0;
    }

    void pop() {
        if (empty()) return;
        del(0);
    }

    T top() {
        if (empty()) return;
        return arr[0];
    }

private:
    T* arr;
    int n;
    int capacity;
};

int main()
{
    int arr[] = {1, 10,2,4,8,7};
    Heap<int> heap;
    for (int i = 0; i < 6; ++i) {
        heap.insert(arr[i]);
    }
    //heap.sort();
    heap.print();
    heap.del(3);
    heap.print();
    heap.increase(1, 10);
    heap.print();
    return 0;
}