数据结构学习----链式栈(Java实现)

栈抽象数据结构 栈接口， 描述栈抽象数据类型，泛型参数T表示数据元素的数据类型：

package com.clarck.datastructure.stack;

/**
 * 栈抽象数据结构 栈接口， 描述栈抽象数据类型，泛型参数T表示数据元素的数据类型
 * 
 * @author clarck
 * 
 * @param <T>
 */
public interface SStack<T> {
    /**
     * 判断栈是否为空
     * 
     * @return
     */
    boolean isEmpty();

    /**
     * 元素x入栈
     * 
     * @param x
     */
    void push(T x);

    /**
     * 出栈，返回栈顶元素
     * 
     * @return
     */
    T pop();

    /**
     * 取栈顶元素， 未出栈
     * 
     * @return
     */
    T get();
}

栈结点类，T指定结点的元素类型：

package com.clarck.datastructure.stack;

/**
 * 单链表结点类，T指定结点的元素类型
 * 
 * @author clarck
 *
 * @param <T>
 */
public class Node<T> {
    /**
     * 数据域，保存数据元素
     */
    public T data;
    
    /**
     * 地址域，引用后继结点
     */
    public Node<T> next;

    /**
     * 构造结点，data指定数据元素，next指定后继结点
     * 
     * @param data
     * @param next
     */
    public Node(T data, Node<T> next) {
        this.data = data;
        this.next = next;
    }

    /**
     * 构造节点
     */
    public Node() {
        this(null, null);
    }

    /**
     * 返回结点元素值对应的字符串
     */
    @Override
    public String toString() {
        return this.data.toString();
    }

    /**
     * 比较两个结点值是否相等，覆盖Object类的equals(obj)方法
     */
    @SuppressWarnings("unchecked")
    @Override
    public boolean equals(Object obj) {
        return obj == this || obj instanceof Node && this.data.equals(((Node<T>)obj).data);
    }
    
}

链式栈：

package com.clarck.datastructure.stack;

/**
 * 链式栈
 * 
 * @author clarck
 * 
 * @param <T>
 */
public class LinkedStack<T> implements SStack<T> {
    /**
     * 栈顶结点
     */
    private Node<T> top;
    
    /**
     * 构造空栈
     */
    public LinkedStack() {
        this.top = null;
    }

    /**
     * 判断栈是否空，若空返回true
     */
    @Override
    public boolean isEmpty() {
        return this.top == null;
    }

    /**
     * 元素x入栈，空对象不能入栈
     */
    @SuppressWarnings({ "unchecked", "rawtypes" })
    @Override
    public void push(T x) {
        //头插入，x结点作为新的栈顶结点
        if (x != null) {
            this.top = new Node(x, this.top);
        }
    }

    /**
     * 出栈，返回栈顶元素，若栈空返回null
     */
    @Override
    public T pop() {
        if (this.top == null)
            return null;
        //取栈顶结点元素
        T temp = this.top.data;
        //删除栈顶结点
        this.top = this.top.next;
        return temp;
    }

    /**
     * 取栈顶元素，未出栈，若栈空返回null
     */
    @Override
    public T get() {
        return this.top == null ? null : this.top.data;
    }

    /**
     * 返回栈所有元素的描述字符串，形式为“(,)”。算法同不带头结点的单链表
     */
    @Override
    public String toString() {
        String str = "(";
        for (Node<T> p = this.top; p != null; p = p.next) {
            str += p.data.toString();
            //不是最后一个结点时后加分隔符
            if (p.next != null) {
                str += ", ";
            }
        }
        return str + ") ";
    }

}

栈的测试类：

package com.clarck.datastructure.stack;

/**
 * 栈的测试类
 * 
 * @author clarck
 * 
 */
public class Stack_test {
    public static void main(String args[]) {
        LinkedStack<Integer> stack2 = new LinkedStack<Integer>();
        System.out.print("Push: ");
        for (int i = 1; i <= 5; i++) {
            Integer intobj = new Integer(i);
            stack2.push(intobj);
            System.out.print(intobj + " ");
        }

        System.out.println("\n Stack: " + stack2.toString());
        System.out.print("Pop: ");
        while (!stack2.isEmpty()) { // 全部出栈
            System.out.print(stack2.pop().toString() + " ");
        }
        System.out.println();
    }

}

测试结果：

Push: 1 2 3 4 5 
 Stack: (5, 4, 3, 2, 1) 
Pop: 5 4 3 2 1