Binary heap implementation (priority queue implementation)

package heap;

/** * @author: huzc * @date: 2022/2/13 15:28 * @description:  Priority queue implementation  */
public class MaxPQ<K extends Comparable<K>>{
    
    private K[] array;

    //  Element number 
    private int n = 0;

    public MaxPQ(int cap) {
    
        array = (K[]) new Comparable[cap + 1];
    }

    public K max() {
    
        return array[1];
    }

    private void swim(int k) {
    
        //  If you float to the top of the pile , You can't go up again 
        while(k > 1 && less(parent(k),k)) {
    
            //  If the first  k  The elements are bigger than the upper layer 
            //  take  k  Change it 
            swap(parent(k),k);
            k = parent(k);
        }
    }

    private void sink(int k) {
    
        //  If it sinks to the bottom of the pile , It doesn't sink 
        while (left(k) <= n) {
    
            //  Let's assume that the left node is larger 
            int older = left(k);
            //  If there is a node on the right , Compare the size 
            if (right(k) <= n && less(older, right(k)))
                older = right(k);
            //  node  k  Older than both children , You don't have to sink 
            if (less(older, k)) break;
            //  otherwise , Does not conform to the structure of the largest heap , sinking  k  node 
            swap(k, older);
            k = older;
        }
    }

    public void insert(K e) {
    
        n++;
        //  Add new elements to the end 
        array[n] = e;
        //  And let it float up to the right position 
        swim(n);
    }

    public K delMax() {
    
        //  The top of the largest heap is the largest element 
        K max = array[1];
        //  Change the biggest element to the last , Delete 
        swap(1,n);
        array[n] = null;
        //  Give Way  array[1]  Sink to the right position 
        sink(1);
        return max;
    }



    private void swap(int i, int j) {
    
        K temp = array[i];
        array[i] = array[j];
        array[j] = temp;
    }

    private boolean less(int i, int j) {
    
        return array[i].compareTo(array[j]) < 0;
    }

    public int parent(int root) {
    
        return root / 2;
    }

    public int left(int root) {
    
        return root * 2;
    }

    public int right(int root) {
    
        return root * 2 + 1;
    }
}