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

源代码如下

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 ++ ;
        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[N] = 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);
    }

}