1、通过ArrayList实现大根堆:
堆:有大根堆和小根堆,对于大根堆来说,其左右子元素比根元素小
1)添加操作:首先将它添加到堆的末尾,然后按以下方式建树:
将最后一个结点作为当前结点
while(当前结点大于它的父节点){
将当前结点和它的父结点交换;
现在当前结点往上进一个层次;
}
2)删除操作:删除之后将最后一个结点成为当前根结点,然后维护该数,其余操作和添加操作类似
package shixian;
import java.util.ArrayList;
/**大根堆*/
public class Heap<E extends Comparable<E>> {
private ArrayList<E> list = new ArrayList<>(); //用数组实现堆
public Heap() {
}
public Heap(E[] objects) {
for(int i = 0; i < objects.length; i++)
list.add(objects[i]);
}
/**添加一个元素*/
public void add(E e) {
list.add(e);
int currentIndex = list.size() - 1;
while(currentIndex > 0) {
int parentIndex = (currentIndex - 1)/2; //找到父节点
if(list.get(currentIndex).compareTo(list.get(parentIndex)) > 0 ) {//大于父节点
E temp = list.get(currentIndex);
list.set(currentIndex, list.get(parentIndex));
list.set(parentIndex, temp);
}else
break;
currentIndex = parentIndex;
}
}
/**删除并返回根节点,然后维护大根堆*/
public E remove() {
if(list.size() == 0) return null;
E root = list.get(0);
list.set(0, list.get(list.size() - 1)); // 将最后一个节点放在根结点
list.remove(list.size() - 1);
int currentIndex = 0;
while(currentIndex < list.size()) {
int leftChildIndex = 2 * currentIndex + 1;
int rigthChildIndex = 2 * currentIndex + 2;
if(leftChildIndex >= list.size()) break;
//选择左右子结点的大者
int maxIndex = leftChildIndex;
if(rigthChildIndex < list.size()) {
if(list.get(maxIndex).compareTo(list.get(rigthChildIndex)) < 0) {
maxIndex = rigthChildIndex;
}
}
//将左右结点中的大者与当前节点比较
if(list.get(currentIndex).compareTo(list.get(maxIndex)) < 0) {
E temp = list.get(maxIndex);
list.set(maxIndex, list.get(currentIndex));
list.set(currentIndex, temp);
currentIndex = maxIndex;
}else {
break;
}
}
return root;
}
public int getSize() {
return list.size();
}
}
-----------------------------------------------------------------------
2、队列:使用链表实现队列
package shixian;
public class GenericQueue<E> {
private java.util.LinkedList<E> list =
new java.util.LinkedList<>();
/**添加一个元素到该队列*/
public void enqueue(E e) {
list.addLast(e);
}
/**从队列删除一个元素*/
public E dequeue() {
return list.removeFirst();
}
/**返回队列中元素的数目*/
public int getSize() {
return list.size();
}
@Override
public String toString() {
return "Queue: "+list.toString();
}
}
测试;
package shixian;
public class TestQueue {
public static void main(String[] args) {
GenericQueue<String> queue = new GenericQueue<>();
queue.enqueue("Tom");
System.out.println("(1) "+queue);
queue.enqueue("Susan");
System.out.println("(2) "+queue);
queue.enqueue("Kim");
queue.enqueue("Michael");
System.out.println("(3) "+queue);
System.out.println("(4) "+queue.dequeue());
System.out.println("(5) "+queue.dequeue());
System.out.println("(6) "+queue);
}
}
/**
* 输出
(1) Queue: [Tom]
(2) Queue: [Tom, Susan]
(3) Queue: [Tom, Susan, Kim, Michael]
(4) Tom
(5) Susan
(6) Queue: [Kim, Michael]
* */
----------------------------------------------------------
3、优先队列:使用堆实现
package shixian;
/**用堆实现优先队列*/
public class MyPriorityQueue<E extends Comparable<E>> {
private Heap<E> heap = new Heap<>();
/**添加元素*/
public void enqueue(E e) {
heap.add(e);
}
/**删除队首元素*/
public E dequeue() {
return heap.remove();
}
public int getSize() {
return heap.getSize();
}
}
测试:
package shixian;
public class TestPriorityQueue {
public static void main(String[] args) {
Patient patient1 = new Patient("John",2);
Patient patient2 = new Patient("Jim",1);
Patient patient3 = new Patient("Tim",5);
Patient patient4 = new Patient("Cindy",7);
MyPriorityQueue<Patient> priorityQueue =
new MyPriorityQueue<>();
priorityQueue.enqueue(patient1);
priorityQueue.enqueue(patient2);
priorityQueue.enqueue(patient3);
priorityQueue.enqueue(patient4);
while (priorityQueue.getSize() > 0) {
System.out.println(priorityQueue.dequeue() + " ");
}
}
static class Patient implements Comparable<Patient>{
private String name;
private int priority;
public Patient(String name,int priority) {
this.name = name;
this.priority = priority;
}
@Override
public String toString() {
return name + "(priority:" + priority + ")";
}
@Override
public int compareTo(Patient patient) {
return this.priority - patient.priority;
}
}
}
/**
*输出
Cindy(priority:7)
Tim(priority:5)
John(priority:2)
Jim(priority:1)
* */