数据结构-堆和优先队列

堆

二叉堆

• 二叉堆是一颗完全二叉树
• 堆中的某个节点的值总是不大于其父节点的值
• 通常这种树称为最大堆（对应的可以定义最小堆）
• 下层的某一元素不一定小于上层的某一元素
• 完全二叉树，那么可以用数组实现
  当根节点为0时
• parent（i)=(i-1)/2;
• left child(i)=2*i+1;
• rightchild(i)=2*i+2;
• 增删元素都在后面进行，然后进行上浮或下沉

最大堆代码实现

package heap;

import java.util.ArrayList;
import dyarray.MyArrayList;
public class MaxHeap<E extends Comparable<E>> {
	private MyArrayList<E> data;

	public MaxHeap() {
		data=new MyArrayList<>();
	}
	public MaxHeap(int capacity){
		data=new MyArrayList<>(capacity);
	}
	//heapify 将任意的数组整理为堆
	public MaxHeap(E[] arr){
		data=new MyArrayList(arr);
		for(int i=parent(data.getSize()-1);i>=0;i--){
			shiftDown(i);
		}
	}
	public int size(){
		return data.getSize();
	}
	public boolean isEmpty(){
		return data.isEmpty();
	}
	public int parent(int index){
		if(index==0){
			throw new IllegalArgumentException();
		}
		return (index-1)/2;
	}
	//左孩子
	public int leftChild(int index){
		return index*2+1;
	}
	//右孩子
	public int rightChild(int index){
		return index*2+2;
	}
	//添加元素
	public void add(E e){
		data.addLast(e);
		shiftUp(data.getSize()-1);
	}
	//上浮
	private void shiftUp(int i) {
		while(i>0&&data.get(parent(i)).compareTo(data.get(i))<0){
			data.swap(i,parent(i));
			i=parent(i);
		}
	}
	//获得最大值
	public E findMax(){
		if(data.isEmpty()){
			throw new IllegalArgumentException();
		}
		return data.get(0);
	}
	//删除最大值
	public E extractMax(){
		E e=findMax();
		data.swap(data.getSize()-1, 0);
		data.removeLast();
		shiftDown(0);
		return e;
	}
	//下沉
	private void shiftDown(int i) {
		while(leftChild(i)<data.getSize()){
			int k=leftChild(i);
			if(k+1<data.getSize()&&data.get(k+1).compareTo(data.get(k))>0){
				k=rightChild(i);
			}
			if(data.get(i).compareTo(data.get(k))<0){
				data.swap(i, k);
				i=k;
			}else{
				break;
			}
		}
	}
	//替换最大值
	public E replace(E e){
		E r=findMax();
		data.set(0, e);
		shiftDown(0);
		return r;
	}
	public void clear(){
		data.clear();
	}
}

优先队列

• 普通队列：先进先出，后进后出
• 优先队列：出队顺序和入队顺序无关，和优先级相关，本质还是队列
• 应用：
  任务管理器中：动态选择优先级最高的任务执行
  游戏中：塔防优先攻击（距离，威胁，先后）

package heap;

import dyarray.MyQueue;

public class PriorityQueue<E extends Comparable<E>> implements MyQueue<E> {
	private MaxHeap<E> heap;
	public PriorityQueue(){
		heap=new MaxHeap<E>();
	}
	@Override
	public int getSize() {
		// TODO Auto-generated method stub
		return heap.size();
	}

	@Override
	public boolean isEmpty() {
		// TODO Auto-generated method stub
		return heap.isEmpty();
	}

	@Override
	public void enqueue(E e) {
		heap.add(e);
	}

	@Override
	public E dequeue() {
		E e=heap.findMax();
		
		return e;
	}

	@Override
	public E getFront() {
		return heap.findMax();
	}

	@Override
	public E getRear() {
		// TODO Auto-generated method stub
		return null;
	}

	@Override
	public void clear() {
		// TODO Auto-generated method stub
		heap.clear();
	}

}