.
可以使用数组线性表实现栈，使用链表实现队列。

栈可以看做是一种特殊类型的线性表，访问、插入和删除其中的元素只能在栈尾进行。用数组线性表来实现栈比用链表来实现实现效率更高

队列，元素只能从队列的末端插入，从开始端访问和删除。由于删除是在线性表的起始位置进行的，所以用链表实现队列比用数组线性表实现效率更高。

这里有两种办法可用来设计校和队列的类。

• 使用继承：可以通过继承数组线性表类ArrayList 来定义栈类，通过继承链表类LinkedList 来定义队列类。
• 使用组合：可以将数组线性表定义为栈类中的数据域，将链表定义为队列类中的数据域，

这两种设计方法都是可行的，但是相比之下，组合可能更好一些，因为它可以定义一个全新的栈类和队列类，而不需要继承数组线性表类与链表类中不必要和不合适的方法。

1、队列的实现

package ReWrite;
public class GenericQueue<E> {
	
	// 队列:尾进前出
	private java.util.LinkedList<E> list = new java.util.LinkedList<E>();
	
	/**
	 * 添加一个元素到队列
	 * @param e
	 */
	public void enqueue(E e) { 
		list.addLast(e);
	}
	
	/**
	 * 从队列删除一个元素
	 */
	public E dequeue() {
		return list.removeLast();
	}
	
	
	public int getSize() {
		return list.size();
	}
	
	@Override
	public String toString() {
		return "Queue:" + list.toString();
	}
}

2、栈的实现

package ReWrite;

public class GenericStack<E> {
	
	private java.util.ArrayList<E> list = new java.util.ArrayList<E>();
	
	/**
	 * 添加一个元素到队列
	 * @param e
	 */
	public void push(E e) { 
		list.add(e);
	}
	
	/**
	 * 从队列删除一个元素
	 */
	public E pop() {
		return list.remove(list.size()-1);
	}
	
	
	public int getSize() {
		return list.size();
	}
	
	@Override
	public String toString() {
		return "stack:" + list.toString();
	}
}

3、测试

package ReWrite;

public class Test {
	public static void main(String[] args) {
		
	/*	
		GenericQueue<String> queue = new GenericQueue<String>();
		queue.enqueue("tom");
		queue.enqueue("Ali");
		queue.enqueue("Sua");
		System.out.println("(1)" + queue);
		System.out.println("(1)" + queue.dequeue());
		
	*/
		
		GenericStack<String> stack = new GenericStack<String>();
		stack.push("apple");
		stack.push("orange");
		stack.push("megon");
		System.out.println("(1)" + stack);
		System.out.println("(2)" + stack.pop());
		System.out.println("(3)" + stack.pop());
		System.out.println("(4)" + stack);

	}
}

4、优先队列

普通的队列是一种先进先出的数据结构，元素在队列尾追加，而从队列头删除。在优先队列( priority queue) 中，元素被赋予优先级。当访问元素时，具有最高优先级的元素最先删除。例如，医院的急救室为病人赋予优先级，具有最高优先级的病人最先得到治疗。

可以使用堆实现优先队列，其中根结点是队列中具有最高优先级的对象。

package ReWrite;

import Sort.Heap;

public class MyPriorityQueue<E extends Comparable<E>> {
	
	private Heap<E> heap = new Heap<>();
	
	public void enqueue(E newObject) {
		heap.add(newObject);
	}
	
	public E dequeue() {
		return heap.remove();
	}
	
	public int getSize() {
		return heap.getSize();
	}
}

测试：

package ReWrite;

public class Test {
	public static void main(String[] args) {
		Patient p1 = new Patient("John",2);
		Patient p2 = new Patient("Jim",1);
		Patient p3 = new Patient("Tim",5);
		Patient p4 = new Patient("Cindy",7);
		
		MyPriorityQueue<Patient> priorityQueue = new MyPriorityQueue<>();
		priorityQueue.enqueue(p1);
		priorityQueue.enqueue(p2);
		priorityQueue.enqueue(p3);
		priorityQueue.enqueue(p4);
		
		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 o) {
			return this.priority - o.priority;
		}
	}
}