队列
FIFO
接口
public interface IQueue<Item> extends Iterable<Item> {
/**
* 入队;添加一个元素
*
* @param item
* 元素
*/
void enqueue(Item item);
/**
* 出队;删除最近添加的元素并返回它
*
* @return 元素
*/
Item dequeue();
/**
* 返回是否为空
*
* @return boolean
*/
boolean isEmpty();
/**
* 返回元素的数量
*
* @return 数量
*/
int size();
}
Test
import org.junit.Before;
import org.junit.Test;
import edu.princeton.cs.algs4.StdOut;
public abstract class AbstractQueueTest<T extends IQueue<String>> {
private T instance;
protected abstract T createInstance();
@Before
public void setUp() {
instance = createInstance();
}
@Test
public void testMain() {
String[] strings = new String[] {"first", "in", "first", "out"};
for (int i = 0; i < strings.length; i++) {
instance.enqueue(strings[i]);
}
StdOut.println("遍历队列: ");
for (String s : instance) {
StdOut.println(s);
}
StdOut.println("遍历队列结束");
while (!instance.isEmpty()) {
StdOut.print(instance.dequeue() + " ");
}
StdOut.println("(" + instance.size() + " left on queue)");
}
}
数组实现
import java.util.Iterator;
import java.util.NoSuchElementException;
public class ResizingArrayQueue<Item> implements IQueue<Item> {
private Item[] a;
private int head = 0;
private int tail = -1;
private int size = 0;
ResizingArrayQueue(int cap) {
a = (Item[])new Object[cap];
}
@Override
public void enqueue(Item item) {
boolean isFull = isFull();
if (isFull) {
// 如果队列满了,将数组扩容一倍
resize(size * 2);
}
a[++tail] = item;
size++;
}
@Override
public Item dequeue() {
Item item = a[head];
// 删除它
a[head++] = null;
size--;
// 当栈大小小于数组的四分之一,将数组大小减半
// 保证数组半满,下次需要改变数组大小之前仍能进行多次的 push() 和 pop()
if (size > 0 && size <= a.length / 4) {
resize(a.length / 2);
}
return item;
}
/**
* 调正数组的大小
*
* @param max
* 新的数组大小
*/
private void resize(int max) {
// 实现逻辑为将数组移动到新的数组中,并将首尾指针重置
Item[] temp = (Item[])new Object[max];
int tempHead = this.head;
int tempTail = this.tail;
int destroyCount = tempHead - 0;
this.head = tempHead - destroyCount;
this.tail = tempTail - destroyCount;
for (int i = 0; i < size; i++) {
temp[i] = a[i + destroyCount];
}
a = temp;
}
/**
* 返回栈是否已满
*
* @return boolean
*/
private boolean isFull() {
return size >= a.length;
}
@Override
public boolean isEmpty() {
return size == 0;
}
@Override
public int size() {
return size;
}
@Override
public Iterator<Item> iterator() {
return new ArrayIterator();
}
public class ArrayIterator implements Iterator<Item> {
/**
* 嵌套类可以访问包含它的类的实例变量(head)
*/
private int i = head;
@Override
public boolean hasNext() {
return i < size + head;
}
@Override
public Item next() {
if (!hasNext()) {
throw new NoSuchElementException("已经没有元素可以迭代!");
}
// 嵌套类可以访问包含它的类的实例变量(a)
return a[i++];
}
@Override
public void remove() {
throw new UnsupportedOperationException("不支持remove操作!");
}
}
}
链表实现
import java.util.Iterator;
import java.util.NoSuchElementException;
public class LinkedQueue<Item> implements IQueue<Item> {
private Node first;
private Node last;
private int size;
private class Node {
Item item;
Node next;
}
@Override
public void enqueue(Item item) {
Node oldLast = this.last;
last = new Node();
last.item = item;
last.next = null;
if (isEmpty()) {
first = last;
} else {
oldLast.next = last;
}
size++;
}
@Override
public Item dequeue() {
Item item = first.item;
first = first.next;
if (isEmpty()) {
last = null;
}
size--;
return item;
}
@Override
public boolean isEmpty() {
return first == null;
}
@Override
public int size() {
return size;
}
@Override
public Iterator<Item> iterator() {
return new ListIterator();
}
private class ListIterator implements Iterator<Item> {
private Node current = first;
@Override
public boolean hasNext() {
return current != null;
}
@Override
public Item next() {
if (current == null) {
throw new NoSuchElementException("没有元素可供遍历了!");
}
Item item = current.item;
current = current.next;
return item;
}
@Override
public void remove() {
throw new UnsupportedOperationException("不支持 remove !");
}
}
}