栈的实现

栈

栈是我们比较熟悉的概念，最大的特点就是先进后出，对栈的模拟有两种方式：
1. 链表
2. 数组

链表的实现

使用单行链表进行模拟

/**
 * 单向链表实现 
 */
class ListStack<T>{

    /**
     * 内部节点类
     */
    private class Node<T>{

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

        T data;
        Node<T> next;
    }

    private int capacity;
    private int size = 0;
    private Node<T> top;//栈顶指针节点    

    public ListStack(){init();}

    public ListStack(int capacity){
        this.capacity = capacity;
        init();
    }

    /**
     * 初始化操作
     */
    private void init(){
        this.size = 0;
        this.capacity = 5;//默认栈空间为5
        top = new Node<T>(null,null);
    }

    /**
     * 返回栈的长度
     * @return
     */
    public int length(){
        return size;
    }

    /**
     * 压入堆栈
     * @param t
     */
    public void push(T t){
        // 判断
        if(this.size <0 || this.size >= this.capacity){
//            this.size--;//使得指针
            throw new RuntimeException("栈空间已满！");
        }

        //创建新的node节点参数一：接受的值，参数二：top指针的下一个节点
        Node<T> curr = new Node(t,top.next);
        top.next = curr;//栈顶指针指向压入的节点
        this.size++;
    }

    /**
     * 出栈操作
     * @return
     */
    public T pop(){

        if(this.size <= 0){
            throw new RuntimeException("栈已经空了！");
        }

        //接受栈顶的值
        Node<T> curr = top.next;
        //top指针指向下一个节点
        top.next = curr.next ;
        curr.next = null;
        this.size--;

        return curr.data;
    }
}

测试

ListStack<String> st  = new ListStack<String>();

        st.push("AAA");
        st.push("BBB");
        st.push("CCC");
        st.push("DDD");
        st.push("EEE");
//        st.push("FFF");
        System.out.println(st.length());
        int len = st.length();
        /*
         * 不能直接在for循环中使用i<st.length(),因为返回值size
         * 一直在减少会导致循环次数出现错误
         */
        for(int i=0;i<len;i++){
            System.out.println(st.pop()+":"+i);
        }

输出：

5
EEE:0
DDD:1
CCC:2
BBB:3
AAA:4

使用数组的实现

class ArrayStack<T>{

    private Object[] obj;
    private int size=0;
    ArrayStack(){
        obj = new Object[5];//默认
    }
    ArrayStack(int capacity){
        obj = new Object[capacity];
    }

    public int length(){
        return this.size;
    }

    public void push(T t){
        if(this.size > length()){
            throw new RuntimeException("栈空间满了！");
        }
        obj[this.size++] = t;
    }

    public T pop(){
        if(this.size < 0){
            throw new RuntimeException("栈空了！");
        }
        return (T)obj[--this.size];
    }
}

测试

/* 测试数组的栈 */
        ArrayStack<Integer> as = new ArrayStack<>();
        as.push(1);
        as.push(2);
        as.push(3);
        as.push(4);
        as.push(5);
//        as.push(6);
        System.out.println(as.length());

        int len2  = as.length();
        for(int i=0;i<len2;i++){
            System.out.println(as.pop()+":"+as.length());
        }

输出

5
5:4
4:3
3:2
2:1
1:0