《尚硅谷数据结构》-栈

目录

栈的概念

 栈的快速入门

使用数组来模拟栈

使用单向链表来模拟栈

栈实现简单计算器

---

栈的概念

栈（stack）是一个先入后出的有序列表。

栈是限制线性表中元素的插入和删除只能在线性表的同一端进行的特殊线性表。

栈顶（Top）：允许插入和删除的一端。

栈底（Bottom）：固定的一端，不变化。

出栈-pop

入栈-push

所以最先放入的元素会到栈底，最后放入的元素会到栈顶。

栈的应用场景

1. 子程序的调用： 在跳往子程序前， 会先将下个指令的地址存到堆栈中， 直到子程序执行完后再将地址取出， 以回到原来的程序中。
2. 处理递归调用： 和子程序的调用类似， 只是除了储存下一个指令的地址外， 也将参数、 区域变量等数据存入堆栈中。
3. 表达式的转换[中缀表达式转后缀表达式]与求值(实际解决)。
4. 二叉树的遍历。
5. 图形的深度优先(depth-first)搜索法。

 栈的快速入门

使用数组来模拟栈

思路：定义一个top来表示栈顶

package queue;

public class ArrayStackDemo {
    public static void main(String[] args) {
        //测试
        ArrayStack arrayStack = new ArrayStack(4);
        arrayStack.push(1);
        arrayStack.push(2);
        arrayStack.push(3);
        arrayStack.push(4);
        arrayStack.push(5);
        arrayStack.list();
        System.out.println("*************");
        tryPop(arrayStack);
        tryPop(arrayStack);
        tryPop(arrayStack);
        tryPop(arrayStack);
        tryPop(arrayStack);
    }
    public static void tryPop(ArrayStack arrayStack){
        try {
            int value = arrayStack.pop();
            System.out.println("出栈的值是"+value);
        }catch(Exception e) {
            System.out.println(e.getMessage());
        }
    }
}

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];
    }

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

    //栈空
    public boolean isEmpty(){
        return top==-1;
    }

    //入栈
    public void push(int value){
        //先判断栈是否满
        if(isFull()){
            System.out.println("栈满");
            return;
        }
        top++;
        stack[top] = value;
    }

    //出栈
    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]);
        }
    }
}

使用单向链表来模拟栈

public class ArrayStackDemo {
    public static void main(String[] args) {
        //测试
        LinkedStack linkedStack = new LinkedStack();
        StackNode s1 = new StackNode(1);
        StackNode s2 = new StackNode(2);
        StackNode s3 = new StackNode(3);

        linkedStack.push(s1);
        linkedStack.push(s2);
        linkedStack.push(s3);
        linkedStack.list();
        System.out.println("*************");
        tryPop(linkedStack);
        linkedStack.list();
        tryPop(linkedStack);
        tryPop(linkedStack);
        linkedStack.list();

    }
    public static void tryPop(LinkedStack linkedStack){
        try {
            StackNode node = linkedStack.pop();
            System.out.println("出栈的值是"+node);
        }catch(Exception e) {
            System.out.println(e.getMessage());
        }
    }
}

class LinkedStack {
    private StackNode head = new StackNode(-1);
    private StackNode top = head; //栈顶节点

    private boolean isEmpty() {
        return top == head;
    }

    public void push(StackNode stackNode) {
        top.setNext(stackNode);
        top = stackNode;
    }

    public StackNode pop() {
        if (isEmpty()) {
            throw new RuntimeException("栈已空");
        }

        StackNode find = head;
        StackNode top_res = top;
        //找到最后一个节点的前一个，并且top一直指向栈顶
        while (true) {
            if (find.getNext() == top) {
                top = find;
                top.setNext(null);
                break;
            }
            find = find.getNext();
        }
        return top_res;
    }

    //按照先入后出原则 打印链表
    public void list() {
        StackNode cur = top;
        StackNode temp = head;
        if (isEmpty()) {
            System.out.println("链表为空");
            return;
        }
        while (true) {
            if (cur == head) {
                break;
            }
            System.out.println(cur.getData());
            //让cur前移一位
            while (true) {
                if (temp.getNext() == cur) {
                    cur = temp;
                    temp = head;
                    break;
                }
                if(temp.getNext()==null){
                    break;
                }
                temp = temp.getNext();
            }
        }

    }
}


class StackNode{
    private int data;
    private StackNode next; //指向下一个节点

    public StackNode(int data) {
        this.data = data;
    }

    public int getData() {
        return data;
    }

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

    public StackNode getNext() {
        return next;
    }

    @Override
    public String toString() {
        return "StackNode{" +
                "data=" + data +
                '}';
    }
}

栈实现简单计算器

使用栈完成计算一个表达式的结果

思路分析：

• 首先通过一个 index 值（索引），来遍历我们的表达式
• if      index指向是一个数字, 就直接入数栈
• else index指向是一个符号, 就分如下情况
•     if      当前符号栈为 空，就直接入栈
•     else 当前符号栈有操作符，就进行比较
•           if      当前的操作符的优先级小于或者等于栈中的操作符， 就需要从数栈中pop出两个数,再从符号栈中pop出一个符号，进行运算，将得到结果入数栈，然后再将当前的操作符入符号栈，
•           else 当前的操作符的优先级大于栈中的操作符， 就直接入符号栈.
• 当表达式扫描完毕，就顺序的从 数栈和符号栈中pop出相应的数和符号（后面弹出的数 符号 前面弹出的数），并运算，将得到结果入数栈.
• 最后在数栈只有一个数字，就是表达式的结果

public class Calculator {
    public static void main(String[] args) {
        String expression = "30+2*6-2";
        ArrayStackCal numStack = new ArrayStackCal(10);
        ArrayStackCal operStack = new ArrayStackCal(10);
        int index = 0;
        int num1 = 0;
        int num2 = 0;
        int oper = 0; //代替运算符
        int res = 0; //保存计算结果
        char ch=' '; //保存每次扫描结果
        String keepNum = "";//用于拼接多位数字， ' '是字符  ""是字符串

        //注意：char可以作为int格式的输入，但是int的输入不能作为char格式的输入

        while(true){
            //依次得到expression的每个字符
            ch = expression.substring(index,index+1).charAt(0);
            //判断ch
            if(operStack.isOper(ch)){ //如果是运算符
                if(!operStack.isEmpty()){
                    //优先级更小或等于
                    if(operStack.priority(ch) <= operStack.priority(operStack.peek())){
                        num1 = numStack.pop();
                        num2 = numStack.pop();
                        oper = operStack.pop();
                        res = numStack.cal(num1, num2, oper);
                        numStack.push(res);
                        operStack.push(ch);
                    }else{//优先级大
                        operStack.push(ch);
                    }
                }else{
                    operStack.push(ch);
                }
            }else{// 如果是数
                //因为每次是扫描一个字符，不能发现是一个数，就立刻入栈，有可能是多位数
                keepNum +=ch;
                //为了防止越界，要先判断ch是不是最后一个
                if(index == expression.length()-1){
                    numStack.push(Integer.parseInt(keepNum));
                }else if (operStack.isOper(expression.substring(index+1,index+2).charAt(0))){
                    //如果后一位是运算符
                    //如果要把单个字符数字转化为int数字，可以用ch-48，48是由ASCII码表得到的
                    numStack.push(Integer.parseInt(keepNum));
                    //清空
                    keepNum = "";
                }
            }
            index++;
            if (index>=expression.length()){
                break; //扫描结束
            }
        }

        //扫描完毕，顺序拿出计算
        while(true){
            //如果符号栈为空，则计算到了最后的结果
            if (operStack.isEmpty()){
                break;
            }else{
                num1 = numStack.pop();
                num2 = numStack.pop();
                oper = operStack.pop();
                res = numStack.cal(num1, num2, oper);
                numStack.push(res);
            }
        }
        System.out.printf("表达式%s=%d",expression,numStack.pop());
    }
}

class ArrayStackCal{
    private int maxSize;
    private int[] stack;
    private int top = -1; //top表示栈顶，初始化的时候没有数据

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

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

    //栈空
    public boolean isEmpty(){
        return top==-1;
    }

    //入栈
    public void push(int value){
        //先判断栈是否满
        if(isFull()){
            System.out.println("栈满");
            return;
        }
        top++;
        stack[top] = value;
    }

    //出栈
    public int pop(){
        if(isEmpty()){
            //抛出异常
            throw new RuntimeException("栈空，没有数据");
        }
        int value = stack[top];
        top--;
        return value;
    }

    //只返回当前栈顶的值，不是pop
    public int peek(){
        return stack[top];
    }
    //显示栈,遍历时需要从栈顶开始显示数据
    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]);
        }
    }

    //返回运算符的优先级，优先级使用数字来表示
    public int priority(int oper){
        if(oper == '*'||oper=='/'){
            return 1;
        }else if(oper == '+' || oper == '-'){
            return 0;
        }else{
            return -1; //暂不考虑其他运算符
        }
    }

    //判断是不是运算符   //char也可以用整型常量赋值
    public boolean isOper(char val){
        return val == '*' || val=='/' || val=='+' || val=='-';
    }

    //计算方法
    public int cal(int num1, int num2, int oper){
        int res = 0; //存放计算结果
        switch (oper){
            case'+':
                res = num1 + num2;
                break;
            case'-':
                res = num2 - num1; //注意顺序
                break;
            case'*':
                res = num1 * num2;
                break;
            case'/':
                res = num2 / num1;
                break;
            default:
                break;
        }
        return res;
    }
}

运行结果：

前中后缀表达式

前缀记法、中缀记法和后缀记法是对表达式的记法，它们之间的区别在于运算符相对与操作数的位置不同。

(3 + 4) × 5 - 6  就是 中缀表达式 
- × + 3 4 5 6             前缀表达式 
3 4 + 5 × 6 -             后缀表达式