栈

栈的抽象类型描述(ADT)：

public interface Stack {
    // Stack values are stacks whose elements are arbitrary objects.
    // 栈元素类型为任意对象
    
    //Modifiers 修改器--修改栈
    public void clear();
    public void push(Object obj);
    public Object pop();    // 删除并返回栈顶元素
    
    //Accessors 访问器--获取栈信息
    public boolean isEmpty();
    public int size();
    public Object peek();    // 返回栈顶元素
    
}

栈的数组实现：

// 数组实现栈
public class ArrayStack implements Stack {
    
    private static final int DEFAULT_SIZE = 10;        // 指定--默认栈深度
    private Object[] array;
    private int top;    // 指向栈顶指针/游标
    
//    public ArrayStack(){}
    
    public ArrayStack() {    // 初始化
        array = new Object[DEFAULT_SIZE];
        top = 0;
    }

    @Override
    public void clear() {
        for(int i = 0; i < top; i++) {
            array[i] = null;
        }
//        for(Object i:array) {
//            i = null;
//        }
        top = 0;
    }

    @Override
    public boolean isEmpty() {
        return top == 0;
    }

    @Override
    <span style="color:#660cc;">public Object peek() {
        if (top == 0) {    // 操作空栈时抛出异常，异常可以自己编写(只要继承Exception)
            throw new IllegalStateException();
        }        
        return array[top - 1];
    }</span>

    @Override
    <span style="color:#660cc;">public Object pop() {
        if (top == 0) {
            throw new IllegalStateException();
        }
        Object obj = array[--top];
        array[top] = null;
        return obj;
    }</span>

    @Override
    public void push(Object obj) {
        if(top == array.length) {
            expand();
        }
        array[top ++] = obj;    // 只能向栈顶插入数据
    }

    @Override
    public int size() {
        return top;
    }

    private void expand() {        // 辅助方法，数组长度加倍
        Object[] newArray = new Object[2*array.length];
        for(int i = 0; i < array.length; i++) {
            newArray[i] = array[i];
        }
        array = newArray;
    }
    
    public String toString() {
//        StringBuilder str = new StringBuilder();
        String buf = "[ ";
        for (int i = 0; i < top; i++) {
            if(i > 0) {          // 在每个元素后面加“,”分隔
                buf += ", ";
            }
            buf += array[i];
        }
        buf += " ]";
        return buf;
    }

}

 

栈--链表实现：

public class LinkedStack implements Stack {

    // 链表节点类
    private static class SLLNode {
        private Object data;
        private SLLNode next;

        public SLLNode() {

        }

        public SLLNode(Object data) {
            this.data = data;
        }

        public SLLNode(Object data, SLLNode next) {
            this.data = data;
            this.next = next;
        }

        public Object getData() {
            return data;
        }

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

        public SLLNode getNext() {
            return next;
        }

        public void setNext(SLLNode next) {
            this.next = next;
        }

        public String toString() {
            return data.toString();
        }
    }

    private SLLNode top;
    private int count;

    public LinkedStack() {        // 初始化 空栈，栈深度任意
        clear();
    }

    @Override
    public void clear() {
        top = null;
        count = 0;
    }

    @Override
    public boolean isEmpty() {
        return top == null;
    }

    @Override
    public Object peek() {
        if (top == null) {
            throw new IllegalStateException();
        }
        return top.data;
    }

    @Override
    public Object pop() {
        if (top == null) {
            throw new IllegalStateException();
        }
        Object val = top.data;
        top = top.next;
        count--;
        return val;
    }

    @Override
    public void push(Object obj) {
        top = new SLLNode(obj, top);
        count++;
    }

    @Override
    public int size() {
        return count;
    }

    public String toString() {
        String buf = "[ ";
        for (SLLNode curr = top; curr != null; curr = curr.next) {
            if (curr != top) {
                buf += ", ";
            }
            buf += curr.data;
        }
        buf += " ]";
        return buf;
    }
}

测试类：

public class ArrayStackTest {

    /**
     * @param args
     */
    public static void main(String[] args) {
        Stack stack = new ArrayStack();
        stack.push("Array");
        stack.push("Number");
        stack.push("String");
        stack.push("Object");
        System.out.println("栈顶：" + stack.peek().toString());
        System.out.println(stack.toString());
//        System.out.println("删除栈顶后：" + stack.pop().toString());
//        System.out.println(stack.toString());
//        stack.clear();
        System.out.println(stack.size());
        System.out.println(stack.isEmpty());
        System.out.println(stack.toString());
    }

}