实现一个简单的栈（底层数组）

栈的特点

1. 先进后出（FILO）或者  后进先出（LIFO）
2. 增删元素皆是在栈顶操作
3. 一次只能删除一个数据项：当前栈顶元素
4. 只允许访问一个数据项：当前栈顶元素

---

所需元素

1. 因为底层用数组实现，所以需要一个数组 stackArray
2. 需要一个指向栈顶的指针top
3. 需要指定数组的大小maxSize

---

分析实现

1. 需要在创建自定义栈类的时候，就确定好一些初始化操作，例如确定数组的大小并初始化数组；
2. 确定栈具有的功能：入栈push()、出栈pop()、查看栈顶元素getTop()、判空isEmpty()、判满isFull()、判长length()、清空clear()

---

代码实现

public class Stack {

    private int maxSize;
    private int top;
    private Object[] stackArr;

    /**
     * 利用构造函数初始化数组
     *
     * @param maxSize
     */
    public Stack(int maxSize) {
        this.maxSize = maxSize;
        stackArr = new Object[maxSize];
        // 相当于栈的指针
        top = 0;
    }

    /**
     * 元素出栈
     *
     * @param i
     */
    public void push(Object i) {
        if (isFull()) {
            throw new RuntimeException("栈已满！");
        }
        stackArr[top++] = i;
    }

    /**
     * 元素入栈
     *
     * @return
     */
    public Object pop() {
        if(isEmpty()) {
            throw new RuntimeException("空栈！");
        }
        // 这里先自减是因为top数组长度，而索引从0开始
        return stackArr[--top];
    }

    /**
     * 获取栈顶元素，只是查看，不删除
     *
     * @return
     */
    public Object getTop() {
        return stackArr[top - 1];
    }

    /**
     * 判断栈是否为空
     *
     * @return
     */
    public boolean isEmpty() {
        return (top == 0);
    }

    /**
     * 判断栈是否已满
     *
     * @return
     */
    public boolean isFull() {
        return (top == maxSize);
    }

    /**
     * 回去栈元素的数量
     *
     * @return
     */
    public int length() {
        return top;
    }

    /**
     * 清空栈
     *
     * @return
     */
    public void clear() {
        while (top != 0) {
            pop();
        }
    }
}

---

测试

public class StackTest {

    public static void main(String[] args) {

        Stack stack = new Stack(10);

        System.out.println( "栈是否为空? " + stack.isEmpty());

        stack.push(2);
        stack.push(1);
        stack.push(6);
        stack.push(3);
        stack.push(5);

        System.out.println("栈长: " + stack.length());

        System.out.println("栈顶元素: " + stack.getTop());

        System.out.println("栈满? " + stack.isFull());

        // 清空栈
        stack.clear();

        System.out.println( "栈是否为空? " + stack.isEmpty());

        stack.push(2);
        stack.push(1);
        stack.push(6);
        stack.push(3);
        stack.push(5);
        // 取出栈元素，并打印
        while(!stack.isEmpty()){
            Object pop = stack.pop();
            System.out.print(pop + "	");
        }
        System.out.println();
    }
}

结果

栈是否为空? true
栈长: 5
栈顶元素: 5
栈满? false
栈是否为空? true
5    3    6    1    2    

---

 

总结

1. 底层用数组实现，简单，但是一开始就要固定栈的大小，并且后期扩容困难；
2. 插入、查找、删除所需时间都是O(1)，因为都是对栈顶元素操作。

---

对比链接：使用链表实现栈

---