java集合源码解读---Queu和Stack的数组和链式实现

栈和队列

所谓的栈，是一个含有至少两个基本操作的抽象数据类型：插入新的元素；删除最近时间插入的元素。遵循FILO（First in，last out，先进后出）的原则。
所谓的队列，也是一个含有至少两个基本操作的抽象数据类型：插入新的元素；删除最久时间插入的元素。遵循FIFO（First in，first out，先进先出）的原则。
关于栈和队列的具体实现，我们即可以借助于数组，也可以采用链表来实现。

1) 栈的数组实现方式

java代码

public class MyStack <E>{

    public int count;
    public Object[] items;

    public MyStack()
    {
        items = new Object[20];
        count = 0;
    }
    public MyStack(int len)
    {
        items = new Object[len];
        count = 0;
    }
    //判断栈是否为空
    boolean isEmpty(){return count==0;}

    //重整数组的大小
    private void resize(int size)
    {
        Object[] newItems = new Object[size];
        for(int i =0;i<count;i++)
            newItems[i] = items[i];
        items = newItems;
    }
    //进栈
    public void push(E e)
    {
        //如果栈满，则重整数组大小。
        if(count == items.length) resize(2*items.length);
        items[count++] = e;//数组的起始索引是0，入栈后，数组的大小应增加1
    }
    //出栈
    public E pop()
    {
        if(count==0) return null; //如果栈为空
        E item = (E)items[count-1];
        items[count-1] = null;
        count--;
        //重整数组大小，节省存储空间。
        if(count>0&&count<=items.length/4) resize(items.length/2); 

        return item;
    }

    //返回栈中的最后一个元素
    public E peek()
    {
        if(count==0) return null;

        E item = (E)items[count-1];
        return item;
    }
}

2）栈的链式实现方式

java代码

public class MyStack<E> {
    Node head;//表示栈顶
    private class Node<E>
    {
        E item;
        Node next;
    }
    public boolean isEmpty()
    {
        return head==null;
    }
    public void push(E e)
    {
        Node<E> node = new Node();
        node.item = e;
        node.next = head; //栈的物理连接顺序是从上到下
        head = node;
    }
    public E pop()
    {
        if(head==null) return null;
        E e = (E)head.item;//栈顶元素先出
        head=head.next;
        return e;
    }
    public E peek()
    {
        if(head == null) return null;
        else 
            return (E)head.item;
    }
}

3）队列的数组实现方式

java代码

//用数组实现循环队列
 public class ArrayQueue <E>
{
    private int front;
    private int rear;
    private int capacity;
    private int count;
    private int capacityIncrement;
    private Object[] itemArray;

    public ArrayQueue(){
        front = 0;
        rear = 0;
        count = 0;
        capacity = 10;
        capacityIncrement = 5;//新增队列的长度。
        itemArray = new Object[capacity];
    }

    boolean isEmpty() {return count==0;}

    //1.入队
    public void insert(E e)
    {
        //1.如果队列已满，就先扩充队列，后插队。
        if(count==capacity) {
            capacity+=capacityIncrement;
            Object[] newArray = new Object[capacity];
        /**
         * 将原队列中的元素原样拷贝到新队列中。如果不是原样拷贝，则会破坏队列的FIFO特性。
         */
        //如果队列中的元素位于itemArray[font.....rear-1]中
        if(front<rear){
            for(int i = front;i<rear;i++){
                newArray[i] = itemArray[i];
            }           
        }
        else{
            //因队列已满，此时front==rear,应该将队列分成两个区间：[0:rear-1] 和[front:count-1]，分别拷贝到新数组的两端。
            //在原队列的中间插入一段新的存储空间。
            //否则，如果在原队列的后面插入新的空间，那么再次进行入队操作时，原来的元素就会被覆盖掉。
            for(int i =0;i<rear;i++){newArray[i] = itemArray[i];}
            for(int i = front;i<count;i++)
            {newArray[i+capacityIncrement] = itemArray[i];}
            front+=capacityIncrement;//然后，将front改为指向其新位置. 
        }
        itemArray = newArray;
       }

        //2.如果队列未满，直接插队。
        itemArray[rear]=e;  
        rear=(rear+1)%capacity; 
        count++;
    }

    //2.出队
    public E remove()
    {
        if(count==0) return null;
        else{
            E item = (E)itemArray[front];
            itemArray[front] = null;
            front = (front+1)%capacity;
            count--;
            return item;
        }
    }
}
//另外一种数组实现循环队列的简单实现
import java.util.NoSuchElementException;  

public class SimpleArrayQueue {  
    protected Object [] data;  
    protected int size,  
                  head,  
                  tail;  
    public SimpleArrayQueue(){  
        final int INITIAL_LENGTH=10;  
        data=new Object[INITIAL_LENGTH];  
        size=0;  
        head=0;  
        tail=-1;  
    }  
    //获取队列的大小和判断队列是否为空  
    public int theSize(){ return size;}  
    public boolean isEmpty(){ return size==0;}  

    //获取队头元素
    public Object front(){  
        if(size==0) throw new NoSuchElementException();  
        return data[head];  
    } 

    //入队操作 
    public void enqueue(Object element){  
        if(size==data.length){  

            //在java中允许将一个数组变量拷贝给另外一个数组变量。这时，两个变量将引用同一个数组。 
            Object [] oldData=data;//保存原数组data
            data=new Object[data.length*2]; //double the length of data 

            //将数组分成两个区间进行拷贝：区间1：[head:OldData.length-1]和区间2：[0:tail]
            //当head==0时，原数组只有区间1这一段需要被拷贝，当head>0时，原数组有区间1和区间2这两段需要被拷贝。
            //copy oldData[head:OldData.length-1] to data[0:OldData.length-1-head]
            System.arraycopy(oldData, head,data,0,oldData.length-head);  
            /*
             * 如果希望将一个数组的所有值拷贝到一个新的数组中去，就要使用Arrays类中的copyOf()方法：
             *  int[] copiedLckyNumbers = Arrays.copyOf(luckyNumbers,2*luckyNumbers.length);
             *  第二个参数是新数组的长度，这个方法通常用来增加数组的大小。
             *  如果数组的元素是数值型，那么多余的元素将被赋值为0;如果是boolean,多余的元素将会被赋值为false；
             *  相反，如果长度小于原始数组的长度，则只会拷贝最前面的数据元素。 
             */

            if(head>0)//拷贝区间2  
                //copy oldData[0:tail] to data [oldData.length-head:oldlenght-1]  
               //System.arraycopy(oldData, 0, data, head+1, tail+1); //错误写法 
            System.arraycopy(oldData, 0, data,oldData.length-head, tail+1);//正确写法
            head=0;  
            tail=oldData.length-1;  
        }  

        tail=(tail+1)%data.length;  
        data[tail]=element;  
        size++;  
    }  

    //出队操作 
    public Object dequeue(){
         /* 注意 :
          * if(size--==0){throw new NoSuchElementException();}//先执行if(size==0),后执行size--;
          * 放置的顺序。
          * 不能写成if(--size==0){ throw new NoSuchElementException(); }
          * 因为当队列中就剩下一个元素时，--size;会使size为0，此时抛出异常，并没有对该异常进行处理。
          * 程序中断，后面的语句无法执行。       
          */
        Object element=data[head];  
        head=(head+1)%data.length;//当队列满的时候size==data.length，即data.length就是当前size的值。
                                 //如果size变小后，head就会跳过下一个元素，而不是顺移下一个,导致下一个元素被”遗忘“了。
        if(size--==0){ throw new NoSuchElementException(); } //先执行if(size==0),后执行size--;
        return element; //程序最后一句一定要是return语句。
    }  

}  

4）队列的链式实现方式

java代码

public class ListQueue <E>{
    private int count;
    private Node<E> front,rear;

    private class Node<E>
    {
        E item;
        Node link;
    }

//   //提供java类的空参数的构造函数。
//   ListQueue()
//  {
//      count =0;
//      front = null;
//      rear = null;
//      Node<E> node = new Node<E>();
//  }

    public boolean isEmpty(){ return count==0;}

    //入队
    public void insert(E e)
    {
        Node<E> newNode = new Node<E>();//初始化为空节点。
        newNode.item = e;

        //如果队为空
        if(rear==null) 
            front = rear = newNode;
        else{
            rear.link = newNode;//新节点连接到队尾处
            rear = newNode;//新节点变成队尾
        }
        count++;
    }
    //出队
    public E remove()
    {
        //如果队为空
        if(count==0) return null;
        else{
            E item = front.item;
            front = front.link;

            if(front==null) { rear = null; }//队列为空。
            count--;
            return item;
        }
    }
    //克隆队列
    public ListQueue<E> clone()
    {
        ListQueue<E>Q = new ListQueue<E>();
        for(Node<E>t=front;t!=null;t=t.link)//for循环的这种写法。等价于while循环。
        Q.insert(t.item);
        return Q;
    }
}