数据结构 栈详解和数组代码实现

1.栈的介绍

1.1栈的特点

1)栈时先进后出的有序列表

2）只能在同一端操作，变化的一端为栈顶，可以插入（入栈）删除（出栈），固定的一端栈底

3）最先放入的元素在栈底，最后放入的在栈顶，删除元素则相反

1.2进栈出栈的图示

1.3栈的应用场景

1）子程序的调用：在跳往子程序前，会先将下个 指令的地址存到堆栈中，直到子程序执行完毕后在将地址取出，以回到原来的程序中

2）处理递归调用：和子程序的调用类似，只是除了存储下一个指令的地址外，也将参数、区域变量等数据存入堆栈中。

3）表达式的转换与求值

4）二叉树的遍历

5）图形的深度优先（depth-first)搜索法

2.数组模拟栈的思路

2.1思路分析

1）使用数组来模拟栈

2）定义一个top来表示栈顶，初始化为-1

3）入栈的操作，当有数据加入到栈时，top++；stack[top]=data;

4.出栈的操作，int value=stack[top];top–;return value

2.2代码实现

package www.git.java;

import java.security.Key;
import java.util.Scanner;

/*
 *@author Liu
 *@Description
 *@data 2021/12/7
 */
public class ArrayStack {
    public static void main(String[] args) {
        Stack stack = new Stack(4);
        String key = "";
        boolean flag = true;
        Scanner scanner = new Scanner(System.in);
        while (flag) {
            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.println("出栈的数据：" + res);
                    } catch (Exception e) {
                        System.out.println(e.getMessage());
                    }
                    break;
                case "exit":
                    scanner.close();
                    flag = false;
                default:
                    break;
            }
        }
    }
}

class Stack {
    private int maxSize;//栈的大小
    private int[] stack;//数组模拟栈
    private int top = -1;//top表示栈顶，初始化为-1

    public Stack(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.println("第" + i + "个数据为" + stack[i]);
        }
    }
}

2.3结果展示

3.栈实现综合计算器

3.1题目要求

请输入一个表达式

计算式：【722-5+1-5+3-3】

3.2思路分析

思路简化；

3+2*6-2

30+2*6-2

7 *2 *2-5+1-5+3-4

1.通过一个index值（索引），来遍历我们的表达式

2.如果我们发现是一个数字，就直接入数栈

3.如果发现扫描到是一个符号，就分如下情况

​ a.如果发现当前的符号栈为空，就直接入栈

​ b.如果符号栈有操作符，就进行比较，如果当前的操作符的优先级小于或者等于栈中的操作符，就需要从数栈中pop出两个数，在从符号栈中pop出一个符号，进行运算，将得到的结果，入数栈，然后将当前的操作符入符号栈，如果当前的操作符的优先级大于栈中的操作符，就直接入符号栈

4.当表达式扫描完毕，就顺序的从数栈和符号栈中pop出相应的数和符号，并运行

5.最后在数栈中只有一个数字，就是表达式的结果

3.3代码实现

public class ArrayStack {
    public static void main(String[] args) {
        String expression = "13+2*6-2";
        Stack numStack = new Stack(10);
        Stack operatorStack = new Stack(10);
        int index = 0;//  用于扫描
        int num1 = 0;
        int num2 = 0;
        int operator = 0;
        int result = 0;
        char ch = ' ';
        String nums = "";
        while (true) {
            ch = expression.substring(index, index + 1).charAt(0);
            if (operatorStack.isOperator(ch)) {
                if (!operatorStack.isEmpty()) {
                    if (operatorStack.priority(ch) <= operatorStack.priority(operatorStack.peek())) {
                        num1 = numStack.pop();
                        num2 = numStack.pop();
                        operator = operatorStack.pop();
                        result = numStack.calculate(num1, num2, operator);
                        numStack.push(result);
                        operatorStack.push(ch);
                    } else {
                        operatorStack.push(ch);
                    }

                } else {
                    operatorStack.push(ch);
                }
            } else {
                //处理多位数入栈
                nums += ch;
                if (index==expression.length()-1) {
                    numStack.push(Integer.parseInt(nums));
                }else {
                    if (operatorStack.isOperator(expression.substring(index + 1, index + 2).charAt(0))) {
                        numStack.push(Integer.parseInt(nums));
                        nums = "";
                    }
                }
            }
            index++;
            if (index >= expression.length()) {
                break;
            }
        }
        while (true) {
            //如果符号栈为空，则计算到最后的结果，数栈中只有一个数字【结果】
            if (operatorStack.isEmpty()) {
                break;
            }
            num1 = numStack.pop();
            num2 = numStack.pop();
            operator = operatorStack.pop();
            result = numStack.calculate(num1, num2, operator);
            numStack.push(result);//入栈

        }
        int result2 = numStack.pop();
        System.out.println(expression + "=" + result2);
    }
}

class Stack {
    private int maxSize;//栈的大小
    private int[] stack;//数组模拟栈
    private int top = -1;//top表示栈顶，初始化为-1

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

    //判断栈是否满
    public boolean isFull() {
        return top == maxSize - 1;
    }

    //返回栈顶的值
    public int peek() {
        return stack[top];
    }

    //判断栈是否为空
    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.println("第" + i + "个数据为" + stack[i]);
        }
    }

    /**
     * 返回运算符的优先级，优先级使用数字来表示
     * 数字越大，则优先级越高
     * 假定目前只有+，-，*，/
     */
    public int priority(int operator) {
        if (operator == '*' || operator == '/') {
            return 1;
        } else if (operator == '+' || operator == '-') {
            return 0;
        } else {
            return -1;
        }
    }

    //判断是不是一个运算符
    public boolean isOperator(char val) {
        return val == '+' || val == '-' || val == '*' || val == '/';
    }

    //计算方法，注意数字的顺序
    public int calculate(int number1, int number2, int operator) {
        int result = 0;
        switch (operator) {
            case '+':
                result = number1 + number2;
                break;
            case '-':
                result = number2 - number1;
                break;
            case '*':
                result = number1 * number2;
                break;
            case '/':
                result = number1 / number2;
                break;
            default:
                break;
        }
        return result;
    }

}

3.4结果展示