二.Java栈与队列的实现：

栈和队列是两种相像的经典的数据类型，都是对数据添加删除做限制的线性表。其不同之处就在于出栈（pop）和出列（dequeue）的方式。栈是先进后出，队列是先进先出。

<1>Java虽说没有所谓的指针，但其实对于每个对象的引用就是指针，所以，栈可以用链表来实现：

public class Stack {    Node first = null;    private class Node {//定义内部类，实现节点的数据类型        String value;        Node next;    }    public boolean isEmpty() {//判空函数        return first == null;    }    public void push(String item) {//入栈        Node oldfirst = first;        first = new Node();        first.value = item;        first.next = oldfirst;    }    public String pop() {//出栈        String item = first.value;        first = first.next;        return item;    }    public static void main(String[] args) {        Stack zhan = new Stack();        System.out.println(zhan.isEmpty());        zhan.push("hello");        zhan.push("world!");        System.out.println(zhan.pop());    }}

当然，栈也可以用简单数组实现：

public class Stack {    String S[];    int n = 0;//代表了栈顶    public Stack(int capacity) {//要求客户端定义栈大小        S = new String[capacity];    }    public boolean isEmpty() {//判空函数        return n == 0;    }    public void push(String item) {//入栈        S[n++] = item;    }    public String pop() {//出栈        String item = S[--n];        S[n] = null;//这两行代码是细节，如果直接返回S[--n]数组中对对象的引用还存在，可能会造成内存浪费。        return item;    }    public static void main(String[] args) {        Stack zhan = new Stack(2);        System.out.println(zhan.isEmpty());        zhan.push("hello");        zhan.push("world!");        System.out.println(zhan.pop());    }}

数组实现栈确实方便简单，但是它却必须规定大小，而在实际应用中我们的客户端往往不知道究竟需要多大的栈，所以我们可以对程序进行改进，动态改变数组大小：

public class Stack {    String S[] = new String[1];    int n = 0;    public boolean isEmpty() //判空函数    {        return n == 0;    }    public void push(String item) //入栈    {        S[n++] = item;        if( n == S.length )            resize(2*S.length);     }    public String pop() //出栈    {        String item = S[--n];        S[n] = null;        if( n == S.length/4)//如果判断是否等于S.length/2可能会出现“抖动”现象            resize(S.length/2);        return item;    }    private void resize(int capacity)//重规定数组大小    {        String copy[] = new String[capacity];        for( int i = 0; i<n; i++ )            copy[i] = S[i];        S = copy;    }    public static void main(String[] args) {        Stack zhan = new Stack();        System.out.println(zhan.isEmpty());        zhan.push("hello");        zhan.push("world!");        System.out.println(zhan.pop());    }}

这样就解决了数组实现栈大小限定的弊端。

对于两种不同的实现，我们应当发现，数组的基本操作要比链表更快，这就使得在处理数据时整体上是数组实现的栈效率更高。不过当数组进行动态伸缩的时候，操作时间会明显变长。所以可以根据实际需求选择实现方法。

<2>对于队列的实现，基本上和栈类似，但是链表实现我们要维护两个节点：first和last，enqueue时从last节点入队，dequeue时从first节点出队：

public class Queue {    private Node first, last;    private class Node{        String value;        Node next;    }    public boolean isEmpty()//判空函数    {        return first == null;    }    public void enqueue(String value)//从last节点入队    {        Node oldlast = last;        last = new Node();        last.value = value;        last.next = null;        if(isEmpty())            first = last;        else            oldlast.next = last;    }    public String dequeue()//从first节点出队    {        String item = first.value;        first = first.next;        return item;    }    public static void main(String[] args) {        Queue duilie = new Queue();        System.out.println(duilie.isEmpty());        duilie.enqueue("hello");        duilie.enqueue("world!");        System.out.println(duilie.dequeue());    }}

以下是数组实现：

public class Queue {    private int first, last;    String S[] = new String[1];    public boolean isEmpty()//判空函数    {        return first == last;    }    public void enqueue(String value)//入队    {        S[last++] = value;        if( last == S.length )            resize(2*S.length);    }    public String dequeue()//出队    {        String item = S[first];        S[first++] = null;        if( last == S.length/4 )            resize(S.length/2);        return item;    }    private void resize(int size)//此处重定义数组比栈稍微复杂，需要找到first节点，将其重新归零     {        String copy[] = new String[size];        int j = 0;        while( S[j] == null)            j++;            for( int i = 0; i<last; i++ )            copy[i] = S[i+j];        S = copy;    }    public static void main(String[] args) {        Queue duilie = new Queue();        System.out.println(duilie.isEmpty());        duilie.enqueue("hello");        duilie.enqueue("world!");        System.out.println(duilie.dequeue());    }}

数组实现多了一些栈不需要考虑的因素，关于两种实现方法的性能分析同栈。

（关于背包的实现，就是一个不可以取出的栈，除掉pop方法即可。）