Data structure + algorithm serialization nine stacks

Introduction to the stack:

1. Stack in English is (stack)
2. The stack is an ordered list of FILO-First In Last Out.
3. A stack is a special linear table that restricts the insertion and deletion of elements in the linear table to the same end of the linear table. The end that allows insertion and deletion is the changing end, called the top of the stack (Top), and the other end is the fixed end, called the bottom of the stack (Bottom).
4. According to the definition of the stack, the first element placed in the stack is at the bottom of the stack, and the last element placed is at the top of the stack, while the deleted element is just the opposite. The last element is deleted first, and the first element is deleted last.

Application scenarios of the stack

1. Subroutine call: Before jumping to the subroutine, the address of the next instruction will be stored on the stack, and the address will be retrieved after the subroutine is executed to return to the original program.     
2. Handling recursive calls: similar to subroutine calls, except that in addition to storing the address of the next instruction, data such as parameters and area variables are also stored on the stack.
3. Expression conversion [infix expression to postfix expression] and evaluation (actual solution).
4. Traversal of the binary tree.
5. Graphics depth-first (depth-first) search method.

The concept of pop and push (as shown in the figure)

Next, we use an array to simulate the stack. The following is an analysis of the idea of ​​implementing the stack:

1. Use an array to simulate the stack

2. Define a top to represent the top of the stack, initialized to -1

3. Stack operation, when data is added to the stack, top++; stack[top] = data;

4. Pop operation, int value = stack[top]; top--, return value

code show as below:

import java.util.Scanner;

public class ArrayStackDemo {

	public static void main(String[] args) {
		//测试一下ArrayStack 是否正确
		//先创建一个ArrayStack对象->表示栈
		ArrayStack stack = new ArrayStack(4);
		String key = "";
		boolean loop = true; //控制是否退出菜单
		Scanner scanner = new Scanner(System.in);
		
		while(loop) {
			System.out.println("show: 表示显示栈");
			System.out.println("exit: 退出程序");
			System.out.println("push: 表示添加数据到栈(入栈)");
			System.out.println("pop: 表示从栈取出数据(出栈)");
			System.out.println("请输入你的选择");
			key = scanner.next();
			switch (key) {
			case "show":
				stack.list();
				break;
			case "push":
				System.out.println("请输入一个数");
				int value = scanner.nextInt();
				stack.push(value);
				break;
			case "pop":
				try {
					int res = stack.pop();
					System.out.printf("出栈的数据是 %d\n", res);
				} catch (Exception e) {
					// TODO: handle exception
					System.out.println(e.getMessage());
				}
				break;
			case "exit":
				scanner.close();
				loop = false;
				break;
			default:
				break;
			}
		}
		
		System.out.println("程序退出~~~");
	}

}

//定义一个 ArrayStack 表示栈
class ArrayStack {
	private int maxSize; // 栈的大小
	private int[] stack; // 数组，数组模拟栈，数据就放在该数组
	private int top = -1;// 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;
	}
	//入栈-push
	public void push(int value) {
		//先判断栈是否满
		if(isFull()) {
			System.out.println("栈满");
			return;
		}
		top++;
		stack[top] = value;
	}
	//出栈-pop, 将栈顶的数据返回
	public int pop() {
		//先判断栈是否空
		if(isEmpty()) {
			//抛出异常
			throw new RuntimeException("栈空，没有数据~");
		}
		int value = stack[top];
		top--;
		return value;
	}
	//显示栈的情况[遍历栈]， 遍历时，需要从栈顶开始显示数据
	public void list() {
		if(isEmpty()) {
			System.out.println("栈空，没有数据~~");
			return;
		}
		//需要从栈顶开始显示数据
		for(int i = top; i >= 0 ; i--) {
			System.out.printf("stack[%d]=%d\n", i, stack[i]);
		}
	}
	
}