数据结构大根堆Java实现

class Heap{
        private int size;
        private int[] heap;
        private int limit = 20;

        public Heap(){
            this.heap = new int[this.limit];
            this.size = 0;
        }
        public Heap(int limit){
            this.limit = limit;
            this.heap = new int[limit];
            size = 0;
        }

        //isEmpty
        public Boolean isEmpty(){
            return size == 0;
        }
        //full
        private Boolean full(){
            return size == limit;
        }
        // remove only one
        public void remove(int value) {
            if (isEmpty()){
                return;
            }
            int index = indexOf(value);
            if (index != -1) {
                swap(heap,index,--size);
                adjustHeapPoll(heap,index);
            }
        }
        // indexof
        private Integer indexOf(int value){
            for (int i = 0; i < size; i++) {
                if (value == heap[i])
                    return i;
            }
            return -1;
        }
        // ensure memory
        private void ensure(){
            if (full()){
                limit = limit<<1;
                int[] newHeap = new int[limit];
                System.arraycopy(heap, 0, newHeap, 0, heap.length);
                heap = newHeap;
            }
        }
        // add
        private void add(int value){
            offer(value);
        }
        //offer
        public void offer(int value){
            ensure();
            heap[size] = value;
            adjustHeapInsert(heap,size++);
        }
        //adjustHeapInsert
        private void adjustHeapInsert(int[] heap,int index){
            while (index > 0 && heap[index] > heap[(index-1)>>1]){
                swap(heap,index,(index - 1)>>1 );
                index = (index - 1)>>1;
            }
        }
        // swap
        private void swap(int[] arr,int i,int j){
            arr[i] = arr[i] ^ arr[j];
            arr[j] = arr[i] ^ arr[j];
            arr[i] = arr[i] ^ arr[j];
        }
        //poll
        public Integer poll(){
            if (isEmpty()){
                return null;
            }
            int max = heap[0];
            swap(heap,0,size--);
            adjustHeapPoll(heap,0);
            return max;
        }
        //peek
        public Integer peek(){
            return full()?null:heap[0];
        }
        //adjustHeapPoll
        private void adjustHeapPoll(int[] heap,int index){
            int left = index<<1 | 1;
            while (left < size){
                int largest = (left+1 <= heap.length && heap[left] < heap[left+1])?(left+1):left;
                largest = heap[largest] > heap[index]? largest:index;
                if (largest == index)
                    break;
                swap(heap,index,largest);
                index = largest;
                left = index<<1 | 1;
            }
        }
        //size
        public Integer size(){
            return size;
        }
    }