数组模拟入栈出栈

首先对栈做一个简单的介绍，栈是一个先入后出的有序列表，可以看成特殊的队列，它限制了数据的插入和删除操作只能在线性表的同一端（栈顶）。

栈的常见操作：

1. 插入：在栈中插入操作称为入栈，最先放入栈中的元素在栈底，最后放入的元素在栈顶。
2. 删除：在栈中删除操作称为出栈，最先删除的元素在栈顶，最后删除的元素在栈底。

入栈和出栈示意图：

实现栈的思路：

1. 使用数组来模拟（单链表也是可以的）；
2. 定义一个top来表示栈顶，初始化为-1；
3. 入栈，top++,stack[top]=data;
4. 出栈，int value = stack[top]，top--，return value;

使用数组来模拟栈，定义一个top来表示栈顶，初始化为-1：

class ArrayStack{
    private int maxSize; //栈的最大容量
    private int[] stack; //数组模拟栈
    private int top = -1; //top指针

    public ArrayStack(int maxSize){
        this.maxSize = maxSize;
        stack = new int[this.maxSize];
    }
}

 入栈，top++,stack[top]=data：

// 1.入栈
public void push(int value){
    if (isFull()){
        System.out.println("栈满，无法执行入栈操作");
        return;
    }
    top++;
    stack[top] = value;
}

出栈，int value = stack[top]，top--，return value：

// 2.出栈
public int pop(){
    if (isEmpty()){
        throw new RuntimeException("栈空，无法执行出栈操作");
    }
    int data = stack[top];
    top--;
    return data;
}

完整模拟代码：

package cn.cwj.stack;

import java.util.Scanner;

public class ArrayStackDemo {
    public static void main(String[] args) {
        ArrayStack arrayStack = new ArrayStack(5);
        Scanner scanner = new Scanner(System.in);
        boolean flag = true;
        while (flag){
            System.out.println("show:显示栈中元素");
            System.out.println("push:入栈");
            System.out.println("pop:出栈");
            System.out.println("exit:退出");
            System.out.println("请输入要执行的操作:");
            String key = scanner.next();
            switch (key){
                case "show":
                    arrayStack.show();
                    break;
                case "push":
                    System.out.println("请输入入栈元素");
                    int data = scanner.nextInt();
                    arrayStack.push(data);
                    break;
                case "pop":
                    arrayStack.pop();
                    break;
                case "exit":
                    flag = false;
                    break;
            }
        }
    }
}
class ArrayStack{
    private int maxSize;
    private int[] stack;
    private int top = -1;

    public ArrayStack(int maxSize){
        this.maxSize = maxSize;
        stack = new int[this.maxSize];
    }

    public boolean isFull(){
        return top == maxSize-1;
    }
    public boolean isEmpty(){
        return top == -1;
    }

    // 1.入栈
    public void push(int value){
        if (isFull()){
            System.out.println("栈满，无法执行入栈操作");
            return;
        }
        top++;
        stack[top] = value;
    }

    // 2.出栈
    public int pop(){
        if (isEmpty()){
            throw new RuntimeException("栈空，无法执行出栈操作");
        }
        int data = stack[top];
        top--;
        return data;
    }

    // 3.显示栈中元素
    public void show(){
        if (isEmpty()){
            System.out.println("栈空，没有元素显示");
        }
        for (int i = top; i>=0 ; i--) {
            System.out.printf("Stack[%d]=%d\n",i,stack[i]);
        }
    }
}