算法（第四版） 能够动态调整数组大小的队列数据结构

import java.util.Iterator;
import edu.princeton.cs.algs4.*;

public class MyQueue<Item>  implements Iterable<Item>
{
private Item[] a = (Item[]) new Object[1];
private int HEAD;
private int TAIL;

public void enqueue(Item item)
{
if (a[TAIL] != null)        addsize(2*a.length);
if (TAIL == (a.length -1))  {   a[TAIL] = item; TAIL = 0;   }
else                        {   a[TAIL] = item; TAIL ++ ;   }
}

public Item dequeue()
{
Item item = a[HEAD];
a[HEAD] = null;
if (HEAD == (a.length - 1))     HEAD = 0;
else                            HEAD ++ ;

4000
if (size() == a.length/4)       subsize(a.length/2);
return item;
}

public boolean isEmpty()
{
return a[HEAD] == null;
}

public int size()
{
if (a[HEAD] == null)    return 0;
if (TAIL <= HEAD)   return TAIL + a.length - HEAD;
else                return TAIL - HEAD;
}

private void addsize(int max)
{   //将大小为队列大小为size() <= man 的队列移动到一个新的大小为max的数组中
Item[] temp = (Item[]) new Object[max];
for (int i = 0; i < (a.length - HEAD); i++)     temp[i] = a[HEAD + i];
for (int i = 0; i < TAIL; i++)                  temp[(a.length - HEAD) + i] = a [i];
HEAD = 0;
TAIL = a.length;
a = temp;
}

private void subsize(int min)
{   //将队列大小为size() <= min 的队列移动到一个新的大小为min的数组中
Item[] temp = (Item[]) new Object[min];
if (HEAD < TAIL)
{
for (int i = 0; i < TAIL - HEAD; i++)   temp[i] = a[HEAD + i];
TAIL = TAIL - HEAD;
HEAD = 0;
a = temp;
} else if (HEAD > TAIL)
{
for (int i = 0; i < (a.length - HEAD); i++) temp[i] = a[HEAD + i];
for (int i = 0; i < TAIL; i++)              temp[(a.length - HEAD) + i] = a [i];
TAIL = a.length - HEAD - TAIL;
HEAD = 0;
a = temp;
} else {
HEAD = 0;
TAIL = 0;
a = temp;
}
}

public Iterator<Item> iterator()
{
return new  MyQueueIterator();
}

public class MyQueueIterator implements Iterator<Item>
{
private int i = HEAD;
public boolean pnext = true;
public boolean hasNext()
{
return pnext;
}
public Item next()
{   Item next;
if (a[i] != null)
{
next = a[i];
i++;
if(i < a.length && a[i] == null) pnext = false;
if(i == a.length) {i = 0;if (a[0] == null) pnext = false;}
if(i == HEAD ) {pnext = false;}
return next;
}
else
{
pnext = false;
return null;
}
}
public void remove() {          }
}

public static void main(String[] args)
{
MyQueue<String> q;
q = new MyQueue<String>();
while (!StdIn.isEmpty())
{
String item = StdIn.readString();
if (!item.equals("-"))
q.enqueue(item);
else if (!q.isEmpty()) StdOut.print(q.dequeue() + " ");
}
StdOut.println("(" + q.size() + " left on queue)");
StdOut.print("HEAD="+q.HEAD+" "+"TAIL="+q.TAIL+"\n");

for (String s : q)
StdOut.print(s+" ");
}
}

下面是原书第88页栈的实现，以供对比学习

import java.util.Iterator;
import edu.princeton.cs.algs4.*;

public class ResizingArrayStack<Item> implements Iterable<Item>
{   /**
*   下压栈（LIFO）栈（能够动态调整数组大小的实现）
*   page 88
*/
//继承迭代接口 Iterator<Item> iterator();
private Item[] a =  (Item[]) new Object[1];
private int N;
public boolean isEmpty() {  return N == 0;  }
public int size() { return N;   }
public void push(Item item)
{   if (N == a.length) resize(2*a.length);
a[N++] = item;  }
public Item pop()
{   Item item = a[--N];
a
= null;    //避免游离
if (N > 0 && N == a.length/4) resize(a.length/2);
return item;
}
private void resize(int max)
{   //将大小为N <= max 的栈移动到一个新的大小为max的数组中
Item[] temp = (Item[]) new Object[max];
for (int i = 0; i < N; i ++)
temp[i] = a[i];
a = temp;
}

/**
*   实现迭代
*/
public Iterator<Item> iterator()
{   //实现迭代接口Iterator<Item> iterator()
return new ReverseArrayIterator();
}
private class ReverseArrayIterator implements Iterator<Item>
{   //支持后进先出的迭代
private int i = N;
public boolean hasNext() { return i > 0;  }
public Item    next()    { return a[--i]; }
public void    remove()  {                }
}

public static void main(String[] agrs)
{
ResizingArrayStack<String> s;
s = new ResizingArrayStack<String>();
while (!StdIn.isEmpty())
{
String item = StdIn.readString();
if (!item.equals("-"))
s.push(item);
else if (!s.isEmpty()) StdOut.print(s.pop() + " ");
}
StdOut.println("(" + s.size() + " left on stack)");
for(String s1 : s)
StdOut.println(s1);
}

}