数组结构与算法-030-035 栈

030 栈的应用场景和介绍

栈的介绍

1. 栈的英文为 stack
2. 栈是一个先入看不出 （FILO-First In Last Out) 的有序列表
3. 栈（stack）是限制线性表中元素的插入和删除只能在线性表的同一端起先的一种特殊线性表。允许插入和删除的一端，为变化的一端，称为栈顶（Top），另一端为固定的一端，称为栈底（Bottom）
4. 根据栈的定义可知，最先放入栈中元素在栈底，最后放入的元素在栈顶，而删除元素刚好相反，最后放入的元素最先删除，最先放入的元素最后删除
5. 出栈(pop）和入栈（push）的概念

栈的应用场景

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

031 栈的思路分析和代码实现

快速入门

1. 用数组模拟栈的使用，由于栈是一种有序列表，当然可以使用数组的结构来存储栈的数据内容

package com.old.stack_030_035;

public class ArrayStackDemo {
    public static void main(String[] args) {
        
    }
}

/**
 * 定义一个栈结构
 */
class ArrayStack{
	/**
     * 栈的大小
     */
    private int maxSize;
    /**
     * 数组，模拟栈，数据就放在该数组中
     */
    private Integer[] stack;

    /**
     * top 表示栈顶，初始化为 -1
     */
    private int top = -1;

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

    /**
     * 栈满
     */
    public boolean isFull() {
        return top == stack.length - 1;
    }

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

    /**
     * 入栈， push
     *
     * @param value
     */
    public void push(int value) {
        if (isFull()) {
            System.out.println("栈满");
            return;
        }
        /**
         * 这里是 ++ 在前 因为 top 是从 -1 开始的，所以要先 ++
         */
        stack[++top] = value;
    }

    /**
     * 出栈 pop
     */
    public int pop() {
        if (isEmpty()) {
            throw new RuntimeException("栈空");
        }
        /**
         * 这里应该是 -- 在后，因为先获取了最大的，再减一
         */
        return stack[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]);
        }
    }

    public void clear() {
        for (int i = 0; i < stack.length; i++) {
            stack[i] = null;
        }
        top = -1;
    }
}

032 栈的功能测试和小结

package com.old.stack_030_035;

import java.util.ArrayList;
import java.util.Scanner;

public class ArrayStackDemo {
   public static void main(String[] args) {
        //测试一下 ArrayStack  是否正确
        ArrayStack stack = new ArrayStack(4);
        stack.push(1);
        stack.push(2);
        stack.push(3);
        stack.push(4);
        stack.push(6);
        stack.show();
        stack.clear();
        String key = "";
        boolean loop = true; // 控制是否退出菜单
        Scanner scanner = new Scanner(System.in);

        while (loop) {
            System.out.println("1.show: 显示栈");
            System.out.println("2.exit: 退出栈");
            System.out.println("3.push: 添加数据到栈");
            System.out.println("4.pop: 从栈取出数据");
            key = scanner.nextLine();
            try {
                switch (key) {
                    case "1":
                        stack.show();
                        break;
                    case "2":
                        scanner.close();
                        System.out.println("流已关闭");
                        loop = false;
                        break;
                    case "3":
                        System.out.println("请输入一个数");
                        int i = scanner.nextInt();
                        stack.push(i);
                        break;
                    case "4":
                        System.out.println("值为：" + stack.pop());
                        break;
                }
                System.out.println();
            } catch (Exception e) {
                System.out.println("异常：" + e.getMessage());
            }
        }

    }
}

/**
 * 定义一个栈结构
 */
class ArrayStack {
    /**
     * 栈的大小
     */
    private int maxSize;
    /**
     * 数组，模拟栈，数据就放在该数组中
     */
    private Integer[] stack;

    /**
     * top 表示栈顶，初始化为 -1
     */
    private int top = -1;

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

    /**
     * 栈满
     */
    public boolean isFull() {
        return top == stack.length - 1;
    }

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

    /**
     * 入栈， push
     *
     * @param value
     */
    public void push(int value) {
        if (isFull()) {
            System.out.println("栈满");
            return;
        }
        /**
         * 这里是 ++ 在前 因为 top 是从 -1 开始的，所以要先 ++
         */
        stack[++top] = value;
    }

    /**
     * 出栈 pop
     */
    public int pop() {
        if (isEmpty()) {
            throw new RuntimeException("栈空");
        }
        /**
         * 这里应该是 -- 在后，因为先获取了最大的，再减一
         */
        return stack[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]);
        }
    }

    public void clear() {
        for (int i = 0; i < stack.length; i++) {
            stack[i] = null;
        }
        top = -1;
    }
}

033-035栈实现综合计算器

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

思路：

034 实现计算器

package com.old.stack_030_035;

public class Calculator {
    public static void main(String[] args) {
        /**
         * 根据前面的思路，完成表达式的运算
         */
        String expression = "3+3*6-2";
        //创建两个栈，数栈，一个符号栈
        ArrayStack2 numberStack = new ArrayStack2(10);
        ArrayStack2 operStack = new ArrayStack2(10);
        //定义需要的相关变量
        int index = 0;
        int num1 = 0;
        int num2 = 0;
        int oper = 0;
        int res = 0;
        ///将每次扫描得到的 char 保存到 ch
        char ch = ' ';
        //开始 while 循环扫描 expression
        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 = numberStack.pop();
                        num2 = numberStack.pop();
                        oper = operStack.pop();
                        res = numberStack.cal(num1, num2, oper);
                        //把运算的结果入数栈
                        numberStack.push(res);
                        operStack.push(ch);
                    } else {
                        //当前的操作符的优先级大于栈中的，就直接入符号栈
                        operStack.push(ch);
                    }
                } else {
                    operStack.push(ch);
                }
            } else {
                /**
                 * 如果是数，直接入数栈
                 * 因为 char 是使用了 ASCII 编码
                 * 它获取的1是字符1，在 ASCII 编码是 49
                 * 因为，他们与真实的数据相差 48 ，所以这里减去了 48
                 */
                numberStack.push(ch - 48);
            }

            //让 index +1 ， 并判断是否扫描到 expression 最后
            index++;
            if (index >= expression.length()){
                break;
            }
        }

        /**
         * 当整个表达式扫描完毕了，就顺序的从 pop 数据
        */
        while (true){
            //如果符号栈，则计算结束，数栈中，只有一个
            if (operStack.isEmpty()){
                break;
            }
            num1 = numberStack.pop();
            num2 = numberStack.pop();
            oper = operStack.pop();
            res = numberStack.cal(num1, num2, oper);
            numberStack.push(res);
        }
        System.out.printf("表达式的结果%s：+ %d" , expression, numberStack.pop());


    }
}


/**
 * 创建一个栈，直接使用前面创建好的
 * 需要扩展功能
 */
class ArrayStack2 {
    /**
     * 栈的大小
     */
    private int maxSize;
    /**
     * 数组，模拟栈，数据就放在该数组中
     */
    private int[] stack;

    /**
     * top 表示栈顶，初始化为 -1
     */
    private int top = -1;

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

    /**
     * 返回当前栈顶的值，但是不是真正的 pop
     */
    public int peek() {
        return stack[top];
    }


    /**
     * 栈满
     */
    public boolean isFull() {
        return top == stack.length - 1;
//        return top == stack.length;
    }

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

    /**
     * 入栈， push
     *
     * @param value
     */
    public void push(int value) {
        if (isFull()) {
            System.out.println("栈满");
            return;
        }
        /**
         * 这里是 ++ 在前 因为 top 是从 -1 开始的，所以要先 ++
         */
        stack[++top] = value;
    }

    /**
     * 出栈 pop
     */
    public int pop() {
        if (isEmpty()) {
            throw new RuntimeException("栈空");
        }
        /**
         * 这里应该是 -- 在后，因为先获取了最大的，再减一
         */
        return stack[top--];
    }

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

    public void clear() {
        stack = new int[maxSize];
        maxSize = -1;
    }

    /**
     * 返回运算符的优先级，优先级是程序来确定, 优先级超高，返回的数字越大
     */
    public int priority(int oper) {
        if (oper == '*' || oper == '/') {
            return 1;
        } else if (oper == '+' || oper == '-') {
            return 0;
        } else {
            //假定目前的表达式只有 +-*/
            return -1;
        }
    }

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

    /**
     * 计算方法
     *
     * @param num1
     * @param num2
     * @param oper
     * @return
     */
    public int cal(int num1, int num2, int oper) {
        //res ， 用于存放计算结果
        int res = 0;
        switch (oper) {
            case '+':
                res = num1 + num2;
                break;
            case '-':
                //注意顺序，要把后弹出的数，作为着数
                res = num2 - num1;
                break;
            case '*':
                res = num1 * num2;
                break;
            case '/':
                //注意顺序，要把后弹出的数，作为着数
                res = num2 / num2;
                break;
        }
        return res;
    }

}

035 计算器支持多位数

package com.weychain.mms.notify.controller.v1_0_0.local;

public class Calculator {
   public static void main(String[] args) {
       /**
        * 根据前面的思路，完成表达式的运算
        */
       String expression = "3+3*6-2";
       expression = "70+20*6-4";
       //创建两个栈，数栈，一个符号栈
       ArrayStack2 numberStack = new ArrayStack2(10);
       ArrayStack2 operStack = new ArrayStack2(10);
       //定义需要的相关变量
       int index = 0;
       int num1 = 0;
       int num2 = 0;
       int oper = 0;
       int res = 0;
       ///将每次扫描得到的 char 保存到 ch
       char ch = ' ';
       //开始 while 循环扫描 expression
       String keepNum = ""; //用于拼接多位数
       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 = numberStack.pop();
                       num2 = numberStack.pop();
                       oper = operStack.pop();
                       res = numberStack.cal(num1, num2, oper);
                       //把运算的结果入数栈
                       numberStack.push(res);
                       operStack.push(ch);
                   } else {
                       //当前的操作符的优先级大于栈中的，就直接入符号栈
                       operStack.push(ch);
                   }
               } else {
                   operStack.push(ch);
               }
           } else {
               /**
                * 如果是数，直接入数栈
                * 因为 char 是使用了 ASCII 编码
                * 它获取的1是字符1，在 ASCII 编码是 49
                * 因为，他们与真实的数据相差 48 ，所以这里减去了 48
                *
                * 1.当处理多位数时，不能发现是一个数就立即入栈，因为他可能是多位数
                * 2.在处理数时，需要向 expression 的表达式的后面 index 后再看一位，如果是数字进行扫描，如果是符号才入栈
                * 3.需要定义一个变量（字符串），用于拼接
                */
               //numberStack.push(ch - 48);
               keepNum += ch;
               /*
               判断下一位字符是不是数字，如果是数，则进行继续扫描
               ,如果是运算符，则入栈
               注意是看最后一位，不是 index++
               */
               if (index == expression.length() -1 ){
                   numberStack.push(ch - 48);
                   break;
               }
               if (operStack.isOper(expression.substring(index + 1, index + 2).charAt(0))) {
                   //如果是运算符，则入栈
                   numberStack.push(Integer.valueOf(keepNum));
                   //清空 keppNum
                   keepNum = "";
               }

           }

           //让 index +1 ， 并判断是否扫描到 expression 最后
           index++;
           if (index >= expression.length()) {
               break;
           }
       }

       /**
        * 当整个表达式扫描完毕了，就顺序的从 pop 数据
        */
       while (true) {
           //如果符号栈，则计算结束，数栈中，只有一个
           if (operStack.isEmpty()) {
               break;
           }
           num1 = numberStack.pop();
           num2 = numberStack.pop();
           oper = operStack.pop();
           res = numberStack.cal(num1, num2, oper);
           numberStack.push(res);
       }
       System.out.printf("表达式的结果%s = %d", expression, numberStack.pop());


   }
}


/**
* 创建一个栈，直接使用前面创建好的
* 需要扩展功能
*/
class ArrayStack2 {
   /**
    * 栈的大小
    */
   private int maxSize;
   /**
    * 数组，模拟栈，数据就放在该数组中
    */
   private int[] stack;

   /**
    * top 表示栈顶，初始化为 -1
    */
   private int top = -1;

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

   /**
    * 返回当前栈顶的值，但是不是真正的 pop
    */
   public int peek() {
       return stack[top];
   }


   /**
    * 栈满
    */
   public boolean isFull() {
       return top == stack.length - 1;
//        return top == stack.length;
   }

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

   /**
    * 入栈， push
    *
    * @param value
    */
   public void push(int value) {
       if (isFull()) {
           System.out.println("栈满");
           return;
       }
       /**
        * 这里是 ++ 在前 因为 top 是从 -1 开始的，所以要先 ++
        */
       stack[++top] = value;
   }

   /**
    * 出栈 pop
    */
   public int pop() {
       if (isEmpty()) {
           throw new RuntimeException("栈空");
       }
       /**
        * 这里应该是 -- 在后，因为先获取了最大的，再减一
        */
       return stack[top--];
   }

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

   public void clear() {
       stack = new int[maxSize];
       maxSize = -1;
   }

   /**
    * 返回运算符的优先级，优先级是程序来确定, 优先级超高，返回的数字越大
    */
   public int priority(int oper) {
       if (oper == '*' || oper == '/') {
           return 1;
       } else if (oper == '+' || oper == '-') {
           return 0;
       } else {
           //假定目前的表达式只有 +-*/
           return -1;
       }
   }

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

   /**
    * 计算方法
    *
    * @param num1
    * @param num2
    * @param oper
    * @return
    */
   public int cal(int num1, int num2, int oper) {
       //res ， 用于存放计算结果
       int res = 0;
       switch (oper) {
           case '+':
               res = num1 + num2;
               break;
           case '-':
               //注意顺序，要把后弹出的数，作为着数
               res = num2 - num1;
               break;
           case '*':
               res = num1 * num2;
               break;
           case '/':
               //注意顺序，要把后弹出的数，作为着数
               res = num2 / num2;
               break;
       }
       return res;
   }

}