堆栈和队列的java实现

1.堆栈

堆栈是一种后进先出(LIFO)的数据结构。主要要实现的方法有判断堆栈是否为空，输出堆栈的顶部元素，添加元素，删除元素，创建一个包含这几个方法的接口如下:

public interface Stack {    public boolean isEmpty();             //判断堆栈是否为空    public Object peek();                 //返回堆栈的顶部元素    public void push(Object theElement);   //从顶部添加元素    public Object pop();                  //删除顶部元素并返回被删除的元素}

1.数组实现

import java.lang.reflect.Array;import java.util.EmptyStackException;public class ArrayStack implements Stack{    int top;            //current top of stack    Object element[];    //element array    /**create a stack with the given initial capacity      *@throws IlleagalArgumentException when initialCapacity<1*/    public ArrayStack(int initialCapacity){        if(initialCapacity<1){            throw new IllegalArgumentException ("initialCapacity must be >=1");        }        element=new Object[initialCapacity];        top=-1;    }    /**create a stack with initial capacity 10*/    public ArrayStack(){        this(10);    }    /** @return true iff stack is empty*/    @Override    public boolean isEmpty() {        // TODO Auto-generated method stub        return top==-1;    }    /** @return top element of stack     *  @throw EmptyStackException when the stack is empty*/    @Override    public Object peek() {        // TODO Auto-generated method stub        if(isEmpty()){            throw new EmptyStackException();        }        return element[top];    }    /** add the element to the top of stack*/    @Override    public void push(Object theElement) {        // TODO Auto-generated method stub        //increase array size if necessary        if(top==element.length-1){            element=changeArrayLength1D(element,2*element.length);        }        //put the element at the top of stack        element[++top]=theElement;    }    private Object[] changeArrayLength1D(Object[] element2, int i) {        // TODO Auto-generated method stub        if(element2.length>i){            throw new IllegalArgumentException("new length too small");        }        Object newArray[]=(Object[])Array.newInstance(element2.getClass().getComponentType(), i);        System.arraycopy(element2, 0, newArray, 0, element2.length);        return newArray;    }    /** @return top element of stack     *  remove top element of stack     *  @throw EmptyStackException when the stack is empty*/    @Override    public Object pop() {        // TODO Auto-generated method stub        if(isEmpty()){            throw new EmptyStackException();        }        Object topElement=element[top];        element[top--]=null;   //enable garbage collection        return topElement;    }    /** @return string converted from stack*/    public String toString(){        StringBuilder s=new StringBuilder("[");        for(int i=top;i>=0;i--){            s.append(element[i].toString()+",");        }        s.append("]");        return s.toString();    }}

构造方法的复杂度是O(n),isEmpty(),peek()，pop方法的复杂度为O(1),push的复杂度是O(n)(当不需要增加容量时为O(1)),toString()方法的复杂度为O(n)。

2.链式实现

import java.util.EmptyStackException;class ChainNode{    Object element;    ChainNode next;       ChainNode(){}    ChainNode(Object element){        this.element=element;    }    ChainNode(Object element,ChainNode next){        this.element=element;        this.next=next;    }}public class LinkedStack implements Stack{    protected ChainNode topNode;    public LinkedStack(int initialCapacity){}    public LinkedStack(){}    @Override    public boolean isEmpty() {        // TODO Auto-generated method stub        return topNode==null;    }    @Override    public Object peek() {        // TODO Auto-generated method stub        if(isEmpty()){            throw new EmptyStackException();        }        return topNode.element;    }    @Override    public void push(Object theElement) {        // TODO Auto-generated method stub        topNode=new ChainNode(theElement,topNode);    }    @Override    public Object pop() {        // TODO Auto-generated method stub        if(isEmpty()){            throw new EmptyStackException();        }        Object topElement=topNode.element;        topNode=topNode.next;        return topElement;    }    public String toString(){        StringBuilder s=new StringBuilder("[");        ChainNode p=topNode;        while(p!=null){            s.append(p.element.toString()+",");            p=p.next;        }        s.append("]");        return s.toString();    }}

除了toString()方法复杂度为O(n)外，其余方法复杂度都为O(1)。

2.队列

队列是一种先进先出(FIFO)的数据结构。主要要实现的方法和堆栈是差不多的，创建一个队列接口如下:

public interface Queue {    public boolean isEmpty();    public Object getFrontElement();//得到队列前端元素    public Object getRearElement(); //得到队列末端元素    public void put(Object theElement);    public Object remove();}

1.数组实现

import java.lang.reflect.Array;public class ArrayQueue implements Queue{    private int front,rear;    private Object[] element;    public ArrayQueue(int initialCapacity){        front=0;        rear=0;        element=new Object[initialCapacity];    }    public ArrayQueue(){        this(10);    }    @Override    public boolean isEmpty() {        // TODO Auto-generated method stub        return rear==front;    }    @Override    public Object getFrontElement() {        // TODO Auto-generated method stub        if(isEmpty()){            throw new EmptyStackException();        }        return element[front];    }    @Override    public Object getRearElement() {        // TODO Auto-generated method stub        if(isEmpty()){            throw new EmptyStackException();        }        int r=0;        if(rear>0){            r=rear-1;        }        else            r=element.length-1;        return element[r];    }    @Override    public void put(Object theElement) {        // TODO Auto-generated method stub        if((rear+1)%element.length==front){            Object newQueue[]=(Object[])Array.newInstance(element.getClass().getComponentType(), 2*element.length);            if(front==0)                System.arraycopy(element, front, newQueue, front, element.length-1);            else{                System.arraycopy(element, front, newQueue, front, element.length-front);                System.arraycopy(element, 0, newQueue, element.length, front-1);            }            rear=front+element.length;            element=newQueue;            element[rear-1]=theElement;        }        else{            element[rear]=theElement;            rear=(rear+1)%element.length;        }    }    @Override    public Object remove() {        // TODO Auto-generated method stub        if(isEmpty()){            throw new EmptyStackException();        }        Object removedElement=element[front];        front=(front+1)%element.length;             return removedElement;    }    public String toString(){        StringBuilder s=new StringBuilder("[");        if(front<rear){            for(int i=front;i<rear;i++){                s.append(element[i].toString()+",");            }        }        else{            for(int i=front;i<element.length;i++){                s.append(element[i].toString()+",");            }            for(int i=0;i<rear;i++){                s.append(element[i].toString()+",");            }        }        s.append("]");        if(!isEmpty()){            s.delete(s.length()-2,s.length()-1);        }        return s.toString();    }}

构造方法复杂度为O(n),put(),toString()方法复杂度为O(n),其余方法复杂度为O(1)。

2.链式实现

import java.util.EmptyStackException;class ChainNode{    Object element;    ChainNode next;    ChainNode(){}    ChainNode(Object element){        this.element=element;    }    ChainNode(Object element,ChainNode next){        this.element=element;        this.next=next;    }}public class LinkedQueue implements Queue{    ChainNode front,rear;    public LinkedQueue(int initialCapacity){}    public LinkedQueue(){}    @Override    public boolean isEmpty() {        // TODO Auto-generated method stub        return front==null;    }    @Override    public Object getFrontElement() {        // TODO Auto-generated method stub        if(isEmpty()){            throw new EmptyStackException();        }        return front.element;    }    @Override    public Object getRearElement() {        // TODO Auto-generated method stub        if(isEmpty()){            throw new EmptyStackException();        }        return rear.element;    }    @Override    public void put(Object theElement) {        // TODO Auto-generated method stub        ChainNode p=new ChainNode(theElement,null);        if(front==null)            front=p;        else            rear.next=p;        rear=p;    }    @Override    public Object remove() {        // TODO Auto-generated method stub        if(isEmpty()){            throw new EmptyStackException();        }        Object removedElement=front.element;        front=front.next;        if(isEmpty())            rear=null;        //enable garbage collection        return removedElement;    }    public String toString(){        StringBuilder s=new StringBuilder("[");        ChainNode p=front;        while(p!=null){            s.append(p.element.toString()+",");            p=p.next;        }        s.append("]");        if(!isEmpty()){            s.delete(s.length()-2,s.length()-1);        }        return s.toString();    }    public static void main(String args[]){        LinkedQueue s=new LinkedQueue();        System.out.println(s.isEmpty());        for(int i=1;i<8;i++){            s.put(new Integer(i));        }        System.out.println(s.isEmpty());        System.out.println(s.toString());        for(int i=1;i<6;i++){            s.remove();        }        System.out.println(s.isEmpty());        System.out.println(s.toString());        for(int i=1;i<4;i++){            s.put(new Integer(i));        }        System.out.println(s.toString());        for(int i=1;i<5;i++){            s.put(new Integer(i));        }        System.out.println(s.toString());        for(int i=1;i<5;i++){            s.put(new Integer(i));        }        System.out.println(s.toString());        System.out.println(s.getFrontElement());        System.out.println(s.getRearElement());    }}

toString()方法复杂度为O(n),其余方法复杂度为O(1)。

3.总结

用数组实现比链式实现的方法少用内存而且时间更快，但是如果存在多个堆栈或队列，而它们的长度总和是一定的，但每个数组的范围都差不多要到从0到它们的长度总和，这个时候使用链式实现方法要更好。