[Prioridad de cola de la cola de la cola] la cola de prioridad (aplicación montón binario)

Gracias código de modificación en la Columbia agolpamiento en una estructura de datos , el clásico de los clásicos.
Gracias código de modificación en la Columbia agolpamiento en una estructura de datos , el clásico de los clásicos.
Gracias código de modificación en la Columbia agolpamiento en una estructura de datos , el clásico de los clásicos.

Perfil de Prioridad de cola

cola de prioridad es una cola , y por lo tanto proporciona las siguientes interfaces

public interface Queue<E> {
	int size();	// 元素的数量
	boolean isEmpty();	// 是否为空
	void enQueue(E element);	// 入队
	E deQueue();	// 出队
	E front();	// 获取队列的头元素
	void clear();	// 清空
}

Cola con cola de prioridad:

• cola común es FIFO principio, que es el primero en salir primero
• cola de prioridad está de acuerdo con el nivel de prioridad de la conducta del equipo,
  tales como los de mayor prioridad elementos que el equipo se dirige prioridad del equipo.

escenarios cola de prioridad:

• Noche ambulatorio de un hospital
  elemento de la cola es paciente
  prioridad es un caso grave de la enfermedad, el tiempo de registro
• Multitarea sistema de programación de funcionamiento
  elemento de la cola es la tarea
  Tipo de tarea prioritaria

Prioridad de aplicación de cola subyacente

• El uso de la pila binaria como una aplicación de cola de prioridad subyacente
• Por Comparador o comparable a personalizar el nivel de prioridad

Binaria montón código fuente cola de prioridad para lograr

Uso de la pila binaria implementado cola de prioridad.

/**
 * 二叉堆实现优先级队列
 * @author yusael
 */
public class PriorityQueue<E> {
	private BinaryHeap<E> heap;
	
	// 通过 comparator 自定义优先级高低
	public PriorityQueue(Comparator<E> comparator) {
		heap = new BinaryHeap<>(comparator);
	}
	
	public PriorityQueue() {
		this(null);
	}
	
	public int size() {
		return heap.size();
	}

	public boolean isEmpty() {
		return heap.isEmpty();
	}
	
	public void clear() {
		heap.clear();
	}

	public void enQueue(E element) {
		heap.add(element);
	}

	public E deQueue() {
		return heap.remove();
	}

	public E front() {
		return heap.get();
	}
}

código de ensayo

Person.java

public class Person implements Comparable<Person> {
	private String name;
	private int boneBreak;
	public Person(String name, int boneBreak) {
		this.name = name;
		this.boneBreak = boneBreak;
	}
	
	@Override
	public int compareTo(Person person) {
		return this.boneBreak - person.boneBreak;
	}

	@Override
	public String toString() {
		return "Person [name=" + name + ", boneBreak=" + boneBreak + "]";
	}
}

Main.java

 public class Main {
	public static void main(String[] args) {
		PriorityQueue<Person> queue = new PriorityQueue<>();
		queue.enQueue(new Person("Jack", 2));
		queue.enQueue(new Person("Rose", 10));
		queue.enQueue(new Person("Jake", 5));
		queue.enQueue(new Person("James", 15));
		
		while (!queue.isEmpty()) {
			System.out.println(queue.deQueue());
		}
	}
}

Person [name=James, boneBreak=15]
Person [name=Rose, boneBreak=10]
Person [name=Jake, boneBreak=5]
Person [name=Jack, boneBreak=2]