【三】栈

一、栈的介绍

1、介绍

• 栈的英文为(stack)
• 栈是一个先入后出(FILO-First In Last Out)的有序列表
• 栈(stack)是限制线性表中元素的插入和删除只能在线性表的同一端进行的一种特殊线性表。允许插入和删除的一端,为变化的一端,称为栈顶(Top),另一端为固定的一端,称为栈底(Bottom)
• 根据栈的定义可知,最先放入栈中元素在栈底,最后放入的元素在栈顶,而删除元素刚好相反,最后放入的元素最先删除,最先放入的元素最后删除
• 图解方式说明出栈(pop)和入栈(push)的概念

2、快速入门

• 用数组和单项链表模拟栈的使用,由于栈是一种有序列表,当然可以使用数组或单向链表的结构来储存栈的数据内容,下面我们就用数组模拟栈的出栈,入栈等操作；
• 实现思路分析,并画出示意图：

• 代码实现（数组）

package com.narwal.stack;

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.show();
                    break;
                case "push":
                    System.out.println("请输入一个数");
                    int value = scanner.nextInt();
                    stack.push(value);
                    break;
                case "pop":
                    stack.pop();
                    break;
                case "exit":
                    scanner.close();
                    loop = false;
                    break;
                default:
                    break;
            }
        }

    }
}

class ArrayStack {
    private int maxSize;  // 栈的容量
    private int top = -1;  // 栈顶指针
    private int[] stack; // 数组,数组模拟栈,数据就放在该数组

    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 void pop() {
        if (isEmpty()) {
            System.out.println("栈已空！");
            return;
        }
        int value = stack[top];
        System.out.printf("出栈成功，stack[%d]=%d\n", top, value);
        top--;

    }

    //显示栈的情况[遍历栈], 遍历时,需要从栈顶开始显示数据
    public void show() {
        if (isEmpty()) {
            System.out.println("遍历失败");
            return;
        }
        for (int i = top; i >= 0; i--) {
            System.out.printf("stack[%d]=%d\n", i, stack[i]);
        }
    }
}

• 代码实现（单项链表）

package com.narwal.stack;
// 用单向链表来生成栈，就是将数组改为单项链表，单项链表自身实现一些方法（就好比数组实现自己的一些方法）

import java.util.Scanner;

public class SingleLinkedListStackDemo {
    public static void main(String[] args) {
        SingleLinkedListStack stack = new SingleLinkedListStack(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":
                    stack.pop();
                    break;
                case "exit":
                    scanner.close();
                    loop = false;
                    break;
                default:
                    break;
            }
        }

    }
}

class SingleLinkedListStack {
    private int maxSize;
    private int top = -1;
    private SingleLinkedList1 singleLinkedList = new SingleLinkedList1();

    public SingleLinkedListStack(int maxSize) { // 构造栈
        this.maxSize = 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++;
        singleLinkedList.add(new HeroNode1(value));
    }

    //出栈-pop, 将栈顶的数据返回
    public void pop() {
        if (isEmpty()) {
            System.out.println("栈空！");
            return;
        }
        HeroNode1 hero = singleLinkedList.getLast();
        System.out.printf("出栈成功:%s\n", hero);
        top--;
    }

    public void list() {
        if (isEmpty()) {
            System.out.println("空栈");
            return;
        }
        singleLinkedList.list();
    }
}

class SingleLinkedList1 {
    private HeroNode1 head = new HeroNode1(0);

    public HeroNode1 getHead() {
        return head;
    }

    // 返回最后一个节点
    public HeroNode1 getLast() {
        HeroNode1 value = head.getNext();
        head.setNext(head.getNext().getNext());  // 删除
        return value;
    }

    // 新添加的节点放在最前面
    public void add(HeroNode1 node) {
        // 创建一个临时节点
        HeroNode1 temp;
        temp = head.getNext();
        head.setNext(node);
        node.setNext(temp);
    }

    // 展示
    public void list() {
        HeroNode1 temp = head.getNext();
        while (temp != null) {
            System.out.println(temp);
            temp = temp.getNext();
        }
    }
}

class HeroNode1 {
    private int no;
    private HeroNode1 next;

    public HeroNode1(int no) {
        this.no = no;
    }

    public HeroNode1 getNext() {
        return next;
    }

    public void setNext(HeroNode1 next) {
        this.next = next;
    }

    public int getNo() {
        return no;
    }

    public void setNo(int no) {
        this.no = no;
    }

    @Override
    public String toString() {
        return "HeroNode1{" +
                "no=" + no +
                '}';
    }
}

二、栈的使用

1、栈实现综合计算器(中缀表达式)

1.1、思路分析(图解)

1.2、代码实现

package com.narwal.stack;

public class Calculator {
    public static void main(String[] args) {
        String expression = "20*3-7+1";
        // 创建一个数栈和一个运算符栈
        ArrayStack1 numStack = new ArrayStack1(10);
        ArrayStack1 operatorStack = new ArrayStack1(10);
        int index = 0;
        int num1;
        int num2;
        int operator;
        int res;
        char ch;
        String keepNum = "";
        // 遍历表达式
        while (true) {
            ch = expression.substring(index, index + 1).charAt(0);
            if (operatorStack.isOperator(ch)) {
                if (operatorStack.isEmpty()) {  // 为空就直接放入栈
                    operatorStack.push(ch);
                } else {
                    // 取出运算符栈顶元素进行比较
                    if (operatorStack.priority(ch) <= operatorStack.priority((char) operatorStack.peak())) {
                        num1 = numStack.pop();
                        num2 = numStack.pop();
                        operator = operatorStack.pop();
                        res = numStack.cal(num1, num2, operator);
                        // 将运算出来的值放入数栈
                        numStack.push(res);
                        // 将该运算符存入运算符栈
                        operatorStack.push(ch);
                    } else {
                        operatorStack.push(ch);
                    }
                }
            } else {  
                keepNum += ch; // 多为数处理
                if (index == expression.length() - 1) {
                    numStack.push(Integer.parseInt(keepNum));
                }else{
                    if (operatorStack.isOperator(expression.substring(index+1,index+2).charAt(0))) {
                        numStack.push(Integer.parseInt(keepNum));
                        keepNum = "";  // 置空

                    }
                }
            }
            index++;
            if (index >= expression.length()) {
                break;
            }
        }
        while (true) {
            if (operatorStack.isEmpty()) {
                break;
            }
            num1 = numStack.pop();
            num2 = numStack.pop();
            operator = operatorStack.pop();
            res = numStack.cal(num1, num2, operator);
            // 将运算出来的值放入数栈
            numStack.push(res);
        }
        int res2 = numStack.pop();
        System.out.printf("%s = %d", expression, res2);
    }
}


class ArrayStack1 {
    private int maxSize;  // 栈的容量
    private int top = -1;  // 栈顶指针
    private int[] stack; // 数组,数组模拟栈,数据就放在该数组

    public ArrayStack1(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 show() {
        if (isEmpty()) {
            System.out.println("空栈");
            return;
        }
        for (int i = top; i >= 0; i--) {
            System.out.printf("stack[%d]=%d\n", i, stack[i]);
        }
    }

    // 判断是否为运算符
    public boolean isOperator(char operator) {
        return operator == '*' || operator == '/' || operator == '+' || operator == '-';
    }

    // 获取栈顶的值
    public int peak() {
        return stack[top];
    }

    // 获取运算符的优先级
    public int priority(char operator) {
        if (operator == '*' || operator == '/') {
            return 1;
        } else if (operator == '+' || operator == '-') {
            return 0;
        } else {
            return -1; // 只允许加减乘除运算
        }
    }

    public int cal(int num1, int num2, int operator) {
        int res = 0;
        switch (operator) {
            case '+':
                res = num1 + num2;
                break;
            case '-':
                res = num2 - num1;
                break;
            case '*':
                res = num1 * num2;
                break;
            case '/':
                res = num2 / num1;
                break;
            default:
                break;
        }
        return res;
    }
}

2、栈实现逆波兰计算器(后缀表达式)

我们完成一个逆波兰计算器,要求完成如下任务:
1) 输入一个逆波兰表达式(后缀表达式),使用栈(Stack), 计算其结果
2) 支持小括号和多位数整数,因为这里我们主要讲的是数据结构,因此计算器进行简化,只支持对整数的计算。
3) 思路分析

4) 代码完成

package com.narwal.stack;

import java.util.ArrayList;
import java.util.List;
import java.util.Stack;

public class PolandNotation {
    public static void main(String[] args) {
        //先定义给逆波兰表达式
        //(30+4)×5-6=> 30 4 + 5 × 6 - => 164
        // 4 * 5 - 8 + 60 + 8 / 2 => 4 5 * 8 - 60 + 8 2 / +
        //测试
        //说明为了方便,逆波兰表达式 的数字和符号使用空格隔开
        String suffixExpression = "3 4 + 5 * 6 -";
        //思路
        //1. 先将 "3 4 + 5 × 6 - " => 放到 ArrayList 中
        List<String> listString = getListString(suffixExpression);
        //2. 将 ArrayList 传递给一个方法,遍历 ArrayList 配合栈 完成计算
        int calculate = calculate(listString);
        System.out.println(calculate);
    }

    //将一个逆波兰表达式, 依次将数据和运算符 放入到 ArrayList 中
    public static List<String> getListString(String suffixExpression) {
        //将 suffixExpression 分割
        String[] splits = suffixExpression.split(" ");
        List<String> list = new ArrayList<>();
        for (String value : splits) {
            list.add(value);
        }
        return list;
    }

    //完成对逆波兰表达式的运算
    /*
    3 4 + 5 * 6 -
    * 1)从左至右扫描,将 3 和 4 压入堆栈;
    2)遇到+运算符,因此弹出 4 和 3(4 为栈顶元素,3 为次顶元素),计算出 3+4 的值,得 7,再将 7 入栈;
    3)将 5 入栈;
    4)接下来是×运算符,因此弹出 5 和 7,计算出 7×5=35,将 35 入栈;
    5)将 6 入栈;
    6)最后是-运算符,计算出 35-6 的值,即 29,由此得出最终结果
    */
    public static int calculate(List<String> ls) {
        // 创建给栈, 只需要一个栈即可
        Stack<String> stack = new Stack<>();
        // 遍历 ls
        for (String item : ls) {
            // 这里使用
            if (item.matches("\\d+")) {  // 当前元素为数字
                stack.push(item);
            } else {
                // pop出两个数，并运算，再入栈(后面拿出来的放前面)
                int num2 = Integer.parseInt(stack.pop());
                int num1 = Integer.parseInt(stack.pop());
                int res;
                switch (item) {
                    case "+":
                        res = num1 + num2;
                        break;
                    case "-":
                        res = num1 - num2;
                        break;
                    case "*":
                        res = num1 * num2;
                        break;
                    case "/":
                        res = num1 / num2;
                        break;
                    default:
                        throw new RuntimeException("运算符有误");
                }
                //把 res 入栈
                stack.push("" + res);
            }
        }
        //最后留在 stack 中的数据是运算结果
        return Integer.parseInt(stack.pop());
    }
}

3、中缀表达式转换为后缀表达式（逆波兰表达式）

3.1、具体步骤如下：

• 1、初始化两个栈：运算符栈s1和存储中间结果栈s2；
• 2、从左到右扫描中缀表达式；
• 3、遇到数是，将其压s2；
• 4、遇到运算符时，比较其与s1栈顶运算符的优先级：

           1.如果 s1 为空,或栈顶运算符为左括号“(”,则直接将此运算符入栈;
           2.否则,若优先级比栈顶运算符的高,也将运算符压入 s1;
           3.否则,将 s1 栈顶的运算符弹出并压入到 s2 中,再次转到(4-1)与 s1 中新的栈顶运算符相比较;

• 5、遇到括号时：

          1 如果是左括号“(”,则直接压入 s1
          2 如果是右括号“)”,则依次弹出 s1 栈顶的运算符,并压入 s2,直到遇到左括号为止,此时将这一对括号丢弃

• 6、重复步骤 2 至 5,直到表达式的最右边
• 7、将 s1 中剩余的运算符依次弹出并压入 s2
• 8、依次弹出 s2 中的元素并输出,结果的逆序即为中缀表达式对应的后缀表达式

小结：

• s1为纯符号栈；
• s2存储更高优先级的运算符和数字；
• 将 s1 中剩余的运算符依次弹出并压入 s2；
• s2逆序就是后缀表达式。

3.2、代码实现中缀表达式转为后缀表达式

• 思路解析

• 代码实现

package com.narwal.stack;

import java.util.ArrayList;
import java.util.List;
import java.util.Stack;

public class PolandNotation {

    public static void main(String[] args) {


        //完成将一个中缀表达式转成后缀表达式的功能
        //说明
        //1. 1+((2+3)×4)-5 => 转成  1 2 3 + 4 × + 5 –
        //2. 因为直接对str 进行操作，不方便，因此 先将  "1+((2+3)×4)-5" =》 中缀的表达式对应的List
        //   即 "1+((2+3)×4)-5" => ArrayList [1,+,(,(,2,+,3,),*,4,),-,5]
        //3. 将得到的中缀表达式对应的List => 后缀表达式对应的List
        //   即 ArrayList [1,+,(,(,2,+,3,),*,4,),-,5]  =》 ArrayList [1,2,3,+,4,*,+,5,–]

        String expression = "1+((2+3)*4)-5";//注意表达式
        List<String> infixExpressionList = toInfixExpressionList(expression);
        System.out.println("中缀表达式对应的List=" + infixExpressionList); // ArrayList [1,+,(,(,2,+,3,),*,4,),-,5]
        List<String> suffixExpressionList = parseSuffixExpreesionList(infixExpressionList);
        System.out.println("后缀表达式对应的List" + suffixExpressionList); //ArrayList [1,2,3,+,4,*,+,5,–]

        System.out.printf("expression=%d", calculate(suffixExpressionList));



		/*
		//先定义给逆波兰表达式
		//(30+4)×5-6  => 30 4 + 5 × 6 - => 164
		// 4 * 5 - 8 + 60 + 8 / 2 => 4 5 * 8 - 60 + 8 2 / +
		//测试
		//说明为了方便，逆波兰表达式 的数字和符号使用空格隔开
		//String suffixExpression = "30 4 + 5 * 6 -";
		String suffixExpression = "4 5 * 8 - 60 + 8 2 / +"; // 76
		//思路
		//1. 先将 "3 4 + 5 × 6 - " => 放到ArrayList中
		//2. 将 ArrayList 传递给一个方法，遍历 ArrayList 配合栈 完成计算

		List<String> list = getListString(suffixExpression);
		System.out.println("rpnList=" + list);
		int res = calculate(list);
		System.out.println("计算的结果是=" + res);

		*/
    }


    //即 ArrayList [1,+,(,(,2,+,3,),*,4,),-,5]  =》 ArrayList [1,2,3,+,4,*,+,5,–]
    //方法：将得到的中缀表达式对应的List => 后缀表达式对应的List
    public static List<String> parseSuffixExpreesionList(List<String> ls) {
        //定义两个栈
        Stack<String> s1 = new Stack<>(); // 符号栈
        //说明：因为s2 这个栈，在整个转换过程中，没有pop操作，而且后面我们还需要逆序输出
        //因此比较麻烦，这里我们就不用 Stack<String> 直接使用 List<String> s2
        //Stack<String> s2 = new Stack<String>(); // 储存中间结果的栈s2
        List<String> s2 = new ArrayList<>(); // 储存中间结果的Lists2

        //遍历ls
        for (String item : ls) {
            if(item.matches("\\d+")){  // 为数字直接加入到s2
                s2.add(item);
            }else if(item.equals("(")){
                s1.add(item);
            }else if(item.equals(")")){
                // 如果s1栈顶元素不是由左括号就弹出加入到s2
                while(!s1.peek().equals("(")){
                    s2.add(s1.pop());
                }
                s1.pop();  // 消掉一个括号
            }else{
                // 当item的优先级小于等于s1栈顶的优先级，就将s1栈顶的元素放入到s2，再测转到4.1与s1中新的栈顶元素比较
                while (s1.size() != 0 && Operation.getValue(s1.peek()) >= Operation.getValue(item)) {
                    s2.add(s1.pop());
                }
                //还需要将item压入栈
                s1.push(item);
            }
        }

        //将s1中剩余的运算符依次弹出并加入s2
        while (s1.size() != 0) {
            s2.add(s1.pop());
        }

        return s2; //注意因为是存放到List, 因此按顺序输出就是对应的后缀表达式对应的List

    }

    //方法：将 中缀表达式转成对应的List
    //  s="1+((2+3)×4)-5";
    public static List<String> toInfixExpressionList(String s) {
        //定义一个List,存放中缀表达式 对应的内容
        List<String> ls = new ArrayList<String>();
        int i = 0; //这时是一个指针，用于遍历 中缀表达式字符串
        String str; // 对多位数的拼接
        char c; // 每遍历到一个字符，就放入到c
        do {
            //如果c是一个非数字，我需要加入到ls
            if ((c = s.charAt(i)) < 48 || (c = s.charAt(i)) > 57) {
                ls.add("" + c);
                i++; //i需要后移
            } else { //如果是一个数，需要考虑多位数
                str = ""; //先将str 置成"" '0'[48]->'9'[57]
                while (i < s.length() && (c = s.charAt(i)) >= 48 && (c = s.charAt(i)) <= 57) {
                    str += c;//拼接
                    i++;
                }
                ls.add(str);
            }
        } while (i < s.length());
        return ls;//返回
    }

    //将一个逆波兰表达式， 依次将数据和运算符 放入到 ArrayList中
    public static List<String> getListString(String suffixExpression) {
        //将 suffixExpression 分割
        String[] split = suffixExpression.split(" ");
        List<String> list = new ArrayList<String>();
        for (String ele : split) {
            list.add(ele);
        }
        return list;

    }

    //完成对逆波兰表达式的运算
	/*
	 * 1)从左至右扫描，将3和4压入堆栈；
		2)遇到+运算符，因此弹出4和3（4为栈顶元素，3为次顶元素），计算出3+4的值，得7，再将7入栈；
		3)将5入栈；
		4)接下来是×运算符，因此弹出5和7，计算出7×5=35，将35入栈；
		5)将6入栈；
		6)最后是-运算符，计算出35-6的值，即29，由此得出最终结果
	 */

    public static int calculate(List<String> ls) {
        // 创建给栈, 只需要一个栈即可
        Stack<String> stack = new Stack<String>();
        // 遍历 ls
        for (String item : ls) {
            // 这里使用正则表达式来取出数
            if (item.matches("\\d+")) { // 匹配的是多位数
                // 入栈
                stack.push(item);
            } else {
                // pop出两个数，并运算， 再入栈
                int num2 = Integer.parseInt(stack.pop());
                int num1 = Integer.parseInt(stack.pop());
                int res = 0;
                if (item.equals("+")) {
                    res = num1 + num2;
                } else if (item.equals("-")) {
                    res = num1 - num2;
                } else if (item.equals("*")) {
                    res = num1 * num2;
                } else if (item.equals("/")) {
                    res = num1 / num2;
                } else {
                    throw new RuntimeException("运算符有误");
                }
                //把res 入栈
                stack.push("" + res);
            }

        }
        //最后留在stack中的数据是运算结果
        return Integer.parseInt(stack.pop());
    }

}

//编写一个类 Operation 可以返回一个运算符 对应的优先级
class Operation {
    private static int ADD = 1;
    private static int SUB = 1;
    private static int MUL = 2;
    private static int DIV = 2;

    //写一个方法，返回对应的优先级数字
    public static int getValue(String operation) {
        int result = 0;
        switch (operation) {
            case "+":
                result = ADD;
                break;
            case "-":
                result = SUB;
                break;
            case "*":
                result = MUL;
                break;
            case "/":
                result = DIV;
                break;
            default:
                System.out.println("不存在该运算符" + operation);
                break;
        }
        return result;
    }

}