堆(Heap)

数组实现堆，堆实现优先队列
优先队列：就跟有优先级的队列，那个重要先执行那个
二叉堆(Binary Heap) ：跟二叉树一样
满二叉树：所有的叶子节点都是满的
完全二叉树：叶子节点不一定满

最大堆：堆中某个节点的值不小于其父节点的值。
最小堆：堆中某个节点的值不大于其父节点的值。

添加元素上浮过程

数据的下沉取出元素

不想搞了。。。。。。。。。。。。。。
还是有问题。。

public class Array<E> {

	private E[] data;//数组
	private int size;//数组中元素个数
	//固定容量的动态数组
	public Array() {
		this(10);
	}
	//自定义数组大小
	public Array(int capacity) {
		data=(E[])new Object[capacity];
		size=0;
	}
	
	//获取数组容量
	public int getCapacity() {
		return data.length;
	}
	
	//获取数组中元素的个数
	public int getSize() {
		return size;
	}
	
	//确认数组是否为空
	public boolean isEmpty() {
		return size==0;
	}
	
	//向所有元素的后面添加一个元素
	public void addLast(E e) {
//		//如果数组满了就抛异常
//		if(size==data.length) {
//			throw new IllegalArgumentException("Add failed. Array is full");
//		}
//		data[size]=e;
//		size++;
		add(size,e);
	}
	
	//向所有元素的前面添加一个元素e
	public void addFirst(E e) {
		add(0,e);
	}
	
	//向数组中的任意位置index添加一个元素e
	public void add(int index,E e) {
		
		//如果数组满了就抛异常
		if(size==data.length) {
			resize(2*data.length);
		}
		
		if(index<0||index>size) {
			throw new IllegalArgumentException("Add failed. Require index<0||index>size");
		}
		
		for(int i=size-1;i>=index;i--) {
			data[i+1]=data[i];
		}
		data[index]=e;
		size++;
	}
	
	private void resize(int capacity) {
		E[] newData=(E[])new Object[capacity];
		for(int i=0;i<size;i++) {
			newData[i]=data[i];
		}
		data=newData;
	}
	//获取索引位置的元素
	public E get(int index) {
		if(index<0||index>=size) {
			throw new IllegalArgumentException("Get failed. index is illegal");
		}
		return data[index];
	}
	
	public E getLast() {
		return get(size-1);
	}
	
	public E getFirst() {
		return get(0);
	}
	
	//修改索引index位置的元素e
	public void set(int index,E e) {
		if(index<0||index>size) {
			throw new IllegalArgumentException("Get failed. index is illegal");
		}
		data[index]=e;
	}
	
	//查找数组中是否有元素e
	public boolean contains(E e) {
		for(int i=0;i<data.length;i++) {
			if(data[i].equals(e)) {
				return true;
			}
		}
		return false;
	}
	//查找数组中元素e所在的索引，如果不存在元素e，则返回-1
	public int find(E e) {
		for(int i=0;i<data.length;i++) {
			if(data[i].equals(e)) {
				return i;
			}
		}
		return -1;
	}
	
	//从数组中删除index位置的元素，返回删除的元素
	public E remove(int index) {
		if(index<0||index>=size) {
			throw new IllegalArgumentException("Remove failed. index is illegal");
		}
		E res=data[index];
		for(int i=index+1;i<size;i++) {
			data[i-1]=data[i];
		}
		size--;
		data[size]=null;
		if(size==(data.length/2)) {
			resize(data.length/2);
		}
		return res;
	}
	
	//从数组中删除第一个元素，返回删除的元素
	public E removeFrist() {
		return remove(0);
	}
	//从数组中删除最后一个元素，返回删除的元素
	public E removeLast() {
		return remove(size-1);
	}
	
	//从数组中删除元素e
	public void removeElement(E e) {
		int index=find(e);
		if(index!=-1) {
			remove(index);
		}
	}

	public void swap(int i,int j){

		if (i<0||i>=size||j<0||j>=size)
			throw new IllegalArgumentException("index is illegal");

		E temp=data[i];
		data[i]=data[j];
		data[j]=temp;
	}
	
	@Override
	public String toString() {
		StringBuilder res=new StringBuilder();
		
		res.append(String.format("Array: Size %d ,Capacity: %d\n", size,data.length));
		res.append('[');
		for(int i=0;i<size;i++) {
			res.append(data[i]);
			if(i!=size-1) {
				res.append(',');
			}
		}
		res.append(']');
		return res.toString();
	}
	
}

public class  MaxHeap<E extends Comparable<E>> {

    private Array<E> data;

    //用数组创建一个最大堆 大小为capacity
    public MaxHeap(int capacity){
        data=new Array<>(capacity);
    }

    //构造方法
    public MaxHeap(){
        data=new Array<>();
    }

    //返回堆中的元素个数
    public int size(){
        return data.getSize();
    }

    //返回一个布尔值，表示堆中是否为空
    public boolean isEmpty(){
        return data.isEmpty();
    }

    //返回完成二叉树的数组表示中，一个索引所表示的元素的父亲结点的索引
    private int parent(int index){
        if (index==0){
            throw new IllegalArgumentException("父节点不能为0");
        }
        return (index-1)/2;
    }

    //返回完成二叉树的数组表示中，一个索引所表示的元素的左孩子结点的索引
    private int leftChild(int index){
        return index*2+1;
    }

    //返回完成二叉树的数组表示中，一个索引所表示的元素的右孩子结点的索引
    private int rightChild(int index){
        return index*2+2;
    }

    //向最大堆中添加元素
    public void add(E e){
        data.addLast(e);//向最后面添加元素
        siftUp(data.getSize()-1);//最后的索引
    }

    //添加元素，上浮到合适位置
    private void siftUp(int k){
        //k>0添加的元素不是第一个根节点   k的父亲结点与它的孩子结点对比,大的往上浮
        while(k>0&&data.get(parent(k)).compareTo(data.get(k))<0){
            data.swap(k,parent(k));//交换孩子结点的值和父亲结点的值
            k=parent(k);//把孩子索引变成父亲索引，方便接下来添加进来的元素与他的父亲结点比较
        }
    }

    //看一下最大堆中的最大元素，也就是堆中的第一个元素
    public E findMax(){
        //如果堆中没有元素
        if (data.getSize()==0){
            throw new IllegalArgumentException("Heap is Empty");
        }
        return data.get(0);
    }

    //取出最大堆中的元素
    public E extractMax(){
        E ret=findMax();//取出最大元素

        //调整堆中元素的位置
        data.swap(0,data.getSize()-1);//交换最后一个元素和第一个元素的位置
        data.removeLast();//删除最后一个元素
        siftDown(0);//使用下沉的方法把元素放到合适的位置
        return ret;
    }

    //取出元素 下沉到合适的位置
    private void siftDown(int k){
        //k结点对应的子节点没为空时
        while(leftChild(k)<data.getSize()){
            int j=leftChild(k);//左孩子索引
            //j+1<data.getSize()判断右孩子是否存在
            // data.get(j+1).compareTo(data.get(j))>0右孩子大于左孩子
            if (j+1<data.getSize()&& data.get(j+1).compareTo(data.get(j))>0){
                //把值下沉到右孩子
                //data.swap(j+1,j);
                //j++;//把左孩子索引换成右孩子索引
                j=rightChild(j);//把左孩子索引换成右孩子索引
            }
            //data[j] 是 leftChild 和 rightChild 中的最大值
            //当父节点大于孩子结点，元素下沉到合适位置了，可以结束循环了
            if (data.get(k).compareTo(data.get(j))>=0){
                break;
            }

            data.swap(k,j);//如果父节点小于孩子结点，就交换两个节点的值
            k=j;//元素位置索引更新
        }
    }

    //取出堆中最大元素，//并且替换成元素e
    public E replace(E e){
        E ret=data.get(0);//取出堆顶元素，返回值
        data.set(0,e);//设置堆顶元素为e
        siftDown(0);//下沉元素堆顶元素e
        return ret;
    }
}