java与数据结构(6)---java实现链栈

栈之链式存储结构链栈

链栈

栈的链式存储结构成为链栈。链栈是没有头结点，头结点就是栈顶指针top。

代码结构

package list;

　　public interface Stackable;公共接口类

　　public class Node;公共结点类

　　class LinkedStack implements Stackable;实现栈接口的链栈类

　　class TestLinkedStack;测试类

公共接口类

package list;

public interface Stackable<T> {
    
    public int Length();

    public boolean isEmpty();

    public boolean isFull();

    public boolean Push(T element);

    public T Pop();

}

公共结点类

package list;

public class Node<T> {
    private T data;
    private Node<T> next;

    Node() {
        this(null,null);
    }

    Node(T data) {
        this(data,null);
    }

    Node(T data, Node<T> next) {
        this.data = data;
        this.next = next;
    }

    public void setData(T data) {
        this.data = data;
    }

    public void setNext(Node<T> next) {
        this.next = next;
    }

    public T getData() {
        return this.data;
    }

    public Node<T> getNext() {
        return this.next;
    }

    public String toString() {
        return getData();
    }
}

实现栈接口的链栈类

//链栈实现类，链栈没有头结点，当链栈为空表时，top = null;
class LinkedStack<T> implements Stackable<T> {
    private Node<T> top;
    
    LinkedStack() {
        this(null);
    }

    //建链栈，element非空引用时，建带top的链栈
    LinkedStack(T element) {
        if(element != null) {
            top = new Node<T>(element);
        }
    }
    
    //获取链栈，长度
    public int Length() {
        if(top == null) {return 0;}
        else {
            int k = 0;
            Node<T> temp = top;
            while(temp != null) {
                k++;
                temp = temp.getNext();
            }
            return k;
        }
    }
    
    //当top==null时，是空栈
    public boolean isEmpty() {
        return top == null;
    }
    
    //链栈没有满栈的概念
    public boolean isFull() {return false;}

    //压栈
    public boolean Push(T element) {
        if(element == null) return false;
        Node<T> node = new Node<T>(element);
        node.setNext(top);
        top = node;
        return true;
    }
    
    //弹栈
    public T Pop() {
        if(isEmpty()) return null;
        T temp = top.getData();
        top = top.getNext();
        return temp;
    }
    
    //重写父类toString方法
    public String toString() {
        if(isEmpty()) return "[ ]";
        int len = Length();
        Node<T> temp = top;
        StringBuffer sb = new StringBuffer("[ ");
        while(temp != null) {
            sb.append(temp.getData()+" ");
            temp = temp.getNext();
        }
        sb.append("]");
        return sb.toString();
    }
}

测试类

//*****************************************************************
//*栈之链式存储结构链栈-JAVA实现
//*@author Nora-Xie
//*@time 2013-10-06PM16:20
//*****************************************************************
package list;

import list.Node;

public class TestLinkedStack {
    public static void main(String[] args) {
        Stackable<String> stack = new LinkedStack<String>("A");
        System.out.println(stack.Length());
        System.out.println(stack);
        stack.Push("B");
        stack.Push("C");
        System.out.println(stack.Length()+" "+stack);
        stack.Pop();
        System.out.println(stack.Length()+" "+stack);
    }
}

链栈和顺序栈对比

顺序栈和链栈的插入、删除操作时间复杂度都是O(1);

顺序栈需要事先确定数组的长度，有可能存在浪费内存空间的情况；

链栈虽然不需要事先确定表长，但因为需要存储链式指针，同时加大了内存开销；

因此，如果数据元素变化不可预测，时大时小，最好使用链栈；如果它的变化空间在可控范围内，则可以考虑使用顺序栈。