THeap.java

public class THeap implements Heap{
    private int[] Heap;
    private int size;
    private int n;

    public THeap(int[] heap,int max,int n){
        this.Heap = heap;
        this.size = max;
        this.n = n;
        buildheap();
    }

    public THeap(int max){
        this.size = max;
        n = 0;
        Heap = new int[max];
    }
    @Override
    public int left(int pos) {
        if(pos<=(n-2)/3) {
            return 3 * pos + 1;
        }
        return -1;
    }

    @Override
    public int right(int pos) {
        if(pos<=(n-4)/3) {
            return 3 * pos + 3;
        }
        return -1;
    }

    @Override
    public int parent(int pos) {
        if(pos>0) {
            return (pos - 1) / 3;
        }
        return -1;
    }

    @Override
    public void insert(int val) {
        if(n<size){
            int curr = n++;
            Heap[curr] = val;
            while(curr != 0 && Heap[curr]<Heap[parent(curr)]){
                swap(Heap,curr,parent(curr));
                curr = parent(curr);
            }
        }
        else{
            System.out.println("The Heap is Full");
        }
    }

    @Override
    public int heapsize() {
        return size;
    }

    @Override
    public int delete() {
        if(n<=0){
            System.out.println("The heap is Empty");
            return -1;
        }

        else{
            swap(Heap,0,--n);
            if(n!=0){
                siftdown(0);
            }
            return Heap[n];
        }
    }

    @Override
    public boolean isLeaf(int pos) {
        return pos<n && pos>=(n-1)/3;
    }

    @Override
    public void siftdown(int pos) {
        if(pos>= 0 && pos<n){
            while(!isLeaf(pos)){
                int curr = pos;
                if(Heap[curr]<=Math.min(Math.min(Heap[left(curr)],Heap[mid(curr)]),Heap[right(curr)]))return;
                if(left(curr)<n && Heap[curr]>Heap[left(pos)]){
                    curr = left(pos);
                }
                if(mid(curr)< n && Heap[curr]>Heap[mid(pos)]){
                    curr = mid(pos);
                }
                if(right(curr) < n && Heap[curr]>Heap[right(pos)]){
                    curr = right(pos);
                }

                swap(Heap,curr,pos);
                pos = curr;
            }
            if(n==2 && Heap[0]>= Heap[1]){
                swap(Heap,0,1);
            }
        }
    }

    public int mid(int pos){
        if(pos<=(n-3)/3) {
            return 3 * pos + 2;
        }
        return -1;
    }

    public static void swap(int[] heap,int i,int j){
        int temp = heap[i];
        heap[i] = heap[j];
        heap[j] = temp;
    }

    public void buildheap(){
        for(int i = (n-1)/3-1;i>=0;i--){
            siftdown(i);
        }
    }

    public int getMin(){
        return Heap[0];
    }

    public static void THeapSort(int[] nums,int start,int end){
        THeap heap = new THeap(nums,nums.length,nums.length);
        heap.buildheap();
        for(int i = 0;i<nums.length;i++){
            if(i>=start && i<=end){
                System.out.printf("%d  ",heap.getMin());
            }
            heap.delete();
        }
    }

    public static void main(String[] args){
        int[] nums = {10,99,100,11,17,19,33,81,12,5,52,63,1,10,10};
        THeapSort(nums,0,14);
    }
}