int a = 3;

int b = 10;

//交换a和b的数据

int temp；

temp = a；//第一步

a = b;//第二步

b = temp;//第三步

package com.wyq.test;

public class MyHeap {

    //堆中的数组要存节点，于是就是一个Node数组

    private Node[] heapArray;

    //数组的最大容量

    private int maxSize;

    //数组中实际节点的数量

    private int currentSize;

    public MyHeap(int size){

        this.maxSize = size;

        this.currentSize = 0;

        this.heapArray = new Node[maxSize];

    }

    //这里为了方便使用，节点类就为一个静态内部类，其中就存了一个int类型的数据，然后get/set方法

    public static class Node{

        private int data;

        public Node(int data){

            this.data = data;

        }

        public int getData() {

            return data;

        }

        public void setData(int data) {

            this.data = data;

        }

    }

    //向堆中插入数据，这里有几点需要注意一下；首先，如果数组最大的容量已经存满了，那么插入失败，直接返回false；

    //然后，数组没有满的话就将新插入的节点放在数组实际存放数据的后一个位置

    //最后就是向上调整，将新插入的节点和父节点交换，重复这个操作，直到放在合适的位置，调整完毕，数组实际存放节点数量加一

    //下面我们就好好看看向上调整的方法

    public boolean insert(int value){

        if (maxSize == currentSize) {

            return false;

        }

        Node newNode = new Node(value);

        heapArray[currentSize] = newNode;

        changeUp(currentSize);

        currentSize++;

        return true;

    }

    //向上调增

    private void changeUp(int current) {

        int parent = (current-1)/2;//得到父节点的数组下标

        Node temp = heapArray[current];//将我们新插入的节点暂时保存起来，这在前面交换那里说过这种做法的好处

        //如果父节点数据小于插入节点的数据

        while(current>0 && heapArray[parent].getData()<temp.getData()){

            heapArray[current] = heapArray[parent];//这里相当于把父节点复制到当前新插入节点的这个位置

            current = parent;//当前指针指向父节点位置

            parent = (parent-1)/2;//继续获取父节点的数组下标，然后又会继续比较新插入节点数据和父节点数据，无限重复这个步骤

        }

        //到达这里，说明了该交换的节点已经交换完毕，换句哈来说就是已经把很多个节点向下移动了一个位置，留下了一个空位置，那就把暂时保存的节点放进去就ok了

        heapArray[current] = temp;

    }

    //删除节点，逻辑比较容易，始终都是删除根节点，然后将最后面一个节点放到根节点位置，然后向下调整就好了；最后就是将实际容量减一就可以了，重点看看向下调整

    public Node delete(){

        Node root = heapArray[0];

        heapArray[0] = heapArray[currentSize-1];

        currentSize--;

        changeDown(0);

        return root;

    }

    //向下调整，大概理一下思路，我们首先将新的根节点临时保存起来，然后要找两个子节点中比较大的那个节点，最后就是比较临时节点和比较大的节点的大小，

    //如果小，那么把那个比较大的节点往上移动到父节点位置，继续重复这个步骤将比较大的子节点往上移动，最后会留下一个空位置，就把临时节点放进去就好

    private void changeDown(int current) {

        Node largeChild;

        Node temp = heapArray[0];//临时节点为新的根节点

        //注意这个while循环的条件，current<currentSize/2可以保证当前节点至少有一个子节点

        while (current<currentSize/2) {

            int leftIndex = 2*current+1;//左子节点数组下标

            int rightIndex = 2*current+2;//右子节点数组下标

            int largeIndex;//比较大的子节点数组下标

            Node leftChild = heapArray[leftIndex];//左子节点

            Node rightChild = heapArray[rightIndex];//右子节点

            if (rightIndex<currentSize && leftChild.getData()<rightChild.getData()) {

                largeChild = rightChild;

                largeIndex = rightIndex;

            }else {

                largeChild = leftChild;

                largeIndex = leftIndex;

            }

            //如果临时节点（即新的根节点）比大的那个子节点还大，那么就直接跳出循环

            if (temp.getData() >= largeChild.getData()) {

                break;

            }

            heapArray[current] = largeChild;

            current = largeIndex;//当前节点的执着呢指向比较大的子节点

        }

        heapArray[current] = temp;//临时节点插入到堆数组中

    }

    //展示堆中的数据

    public void display(){

        System.out.print("堆中的数据为：");

        for (int i = 0; i < currentSize; i++) {

            System.out.print(heapArray[i].getData()+"  ");

        }

    }

    public static void main(String[] args) {

        MyHeap heap = new MyHeap(10);

        heap.insert(3);

        heap.insert(5);

        heap.insert(1);

        heap.insert(10);

        heap.insert(6);

        heap.insert(7);

        heap.display();

        System.out.println();

        System.out.print("删除操作之后");

        heap.delete();

        heap.display();

    }

}