基础数据结构——栈和队列

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

public class MyStack<E> {
    public int count;
    public Object [] items;

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

    public MyStack (){

        items=new Object[20];
        count=0;
    }

    public MyStack (int len){

        items=new Object[len];
        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;
    }

    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） 栈的链式实现方式

public class MyStack<E> {
    private class Node{
        E item;
        Node next;
    }

    Node head;

    public boolean isEmpty(){
        return head==null;
    }

    public void push(E t){
        Node node=new Node();
        node.item=t;
        node.next=head;
        head=node;
    }

    public E pop(){

        if(head==null)
            return null;
        E t=head.item;
        head=head.next;

        return t;
    }

    public E peek(){
        if(head==null)
            return null;
        else
            return head.item;
    }
}

3） 队列的数组实现

Java代码

public class ArrayQueue<E> {
    private int front;
    private int rear;
    private int count;
    private int capacity;
    private int capacityIncrement;


    private Object[] itemArray;

    public ArrayQueue(){
        front=0;
        rear=0;
        count=0;
        capacity=10;
        capacityIncrement=5;
        itemArray=new Object[capacity];
    }

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

    public void insert(E e){
        if(count==capacity){
            capacity+=capacityIncrement;
            Object [] newArray=new Object[capacity];
//          for(int i=0;i<count;i++){
//              newArray[i]=itemArray[i];
//          }
            if(front<rear){
                //如果元素位于itemArray[front:rear-1]中
                for(int i=front;i<rear;i++){
                    newArray[i]=itemArray[i];
                }
            }else{
                //否则，将元素分成两个区间
                //区间1：itemArray[0:rear-1]
                for(int i=0;i<rear;i++){
                    newArray[i]=itemArray[i];
                }
                //区间2：itemArray[front:count-1]
                for(int i=front;i<count;i++){
                    newArray[i]=itemArray[i];
                }

                front+=capacityIncrement;//然后，将front改为指向其新位置
            }
            itemArray=newArray;
        }
        itemArray[rear]=e;
        rear=(rear+1)%capacity;
        count++;
    }

    public E remove(){
        if(count==0){
            return null;
        }
        else{
            E temp=(E) itemArray[front];
            itemArray[front]=null;
            front=(front+1)%capacity;
            count--;

            return temp;
        }
    }
}

数组的另一种更简单的实现方式：

Java代码

import java.util.NoSuchElementException;

public class ArrayQueue {
    protected Object [] data;
    protected int size,
                    head,
                    tail;
    public ArrayQueue(){
        final int INITIAL_LENGTH=100;
        data=new Object[INITIAL_LENGTH];
        size=0;
        head=0;
        tail=-1;
    }

    public int size(){
        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){
            //double the length of data
            Object [] oldData=data;
            data=new Object[data.length*2];

            //copy oldData[head...OldData.length-1]
            //to  data[0... OldData.length-1-head]
            System.arraycopy(oldData, head,data , 0, oldData.length-head);

            if(head>0)
                //copy oldData[0...tail] to data [head+1 .. oldlenght-1]
                System.arraycopy(oldData, 0, data, head+1, tail+1);
            head=0;
            tail=oldData.length-1;
        }

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

    public Object dequeue(){
        if(size--==0){
            throw new NoSuchElementException();
        }
        Object element=data[head];
        head=(head+1)%data.length;

        return element;
    }

}

4） 队列的链式实现方式

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

    private Node<E> front,rear;
    private int count;

    public boolean empty(){
        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 e=front.item;
            front=front.link;
            if(front==null){
                rear=null;
            }

            count--;

            return e;
        }
    }

    public ListQueue<E> clone(){
        ListQueue<E> Q=new ListQueue<E>();

        for(Node<E> t=front;t!=null;t=t.link)
            Q.insert(t.item);
        return Q;
    }
}