数据结构--栈

栈的介绍

1）：栈的英文名叫做：stack
2）：栈是一个先入后出的有序列表
3）：栈是限制线路列表中元素的插入和删除只能在线性表的同一端进行的一种特殊线性表。允许插入和删除的一端，称为栈顶，另外一端称为栈底。
4）：根据栈的定义可知，最先放入的元素在栈底，最后放入的元素在栈顶，而删除元素刚好相反，最后放入的元素最先删除，最先放入的元素最后删除。

栈的应用场景：
1、子程序的调用：跳往子程序前，会先将下个指令的地址存在栈堆中，直到子程序指向完毕后再从地址取出，以回来原来的程序。
2、处理递归调用：和子程序的调用类似，
3、表达式的转换
4、二叉树的遍历
5、图形的深度优先搜索法。

代码实现栈

用数组来模拟栈的思路分析：

1、使用数组模拟栈
2、用top定义来表示栈顶，初始化为-1
3、入栈的操作，当有数据加入到栈的时候，top++，stack[top]=data。
4、出栈的操作，int value=stack[top];top–,retrurn value。
代码演示：

package com.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.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",res);
                    }catch (Exception e){
                        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.printf("栈满");
            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.printf("没有数据！");
            return;
        }
        for (int i = top;i>=0;i--){
            System.out.println("输出的数据是"+stack[i]);
        }
    }
}

用栈来完成计算一个表达式

思路：

两个栈：
一个栈用来存放数字的
另外一个栈用来存放运算符
使用栈完成表达式的计算思路：
1、通过一个index值（索引），来遍历我们的表达式
2、如果我们发现index是一个数字，就直接入数栈
3、如果发现扫描到的是一个符号，就分如下情况解决
3、1如果发现当前的符号栈为空，就直接入栈。
3、2如果符号栈有操作符，就进行比较，如果当前的操作符优先级小于或者等于栈中的操作符，就需要从数栈中pop出两个数，再从符号栈中pop中一个符号，进行运算，将得到的结果，入数栈，然后将当前的符号入符号栈，如果符号栈有操作符，就进行比较，如果当前的操作符优先级大于或者等于栈中的操作符，就直接入符号栈，
4、当扫描完毕后，就顺序的从数栈和符号栈pop出相应的数和符号，并运算，
5、最后数栈只有一个数字，就是表达式的结果。
ASCll表

代码演示：

package com.stack;

public class ArrayTest1 {
    public static void main(String[] args) {
        String expression = "10*3-8+1";
        ArrayStack1 nums= new ArrayStack1(10);
        ArrayStack1 cal1= new ArrayStack1(10);
        int index=0;
        int a=0;
        int b=0;
        char ch=' ';
        int res=0;
        int oper=0;
        String keep="";
        while (true){
            //得到单个字符
            ch = expression.substring(index,index+1).charAt(0);
            //判断是数字还是运算符
            if (cal1.isOper(ch)){
                if (!cal1.isEmpty()){//不为空
                    if (cal1.priority(ch)<= cal1.priority(cal1.peek())){
                        a=nums.pop();
                        b=nums.pop();
                        oper=cal1.pop();
                        res=nums.cal(a,b,oper);
                        nums.push(res);
                        cal1.push(ch);
                    }else {
                        cal1.push(ch);
                    }
                }else {
                    cal1.push(ch);
                }
            }else {//不是运算符
                //nums.push(ch-48);
                keep+=ch;
                //到栈的最后
                if (index == expression.length()-1){
                    nums.push(Integer.parseInt(keep));
                }else {
                    if (cal1.isOper(expression.substring(index+1,index+2).charAt(0))){//是运算符
                        nums.push(Integer.parseInt(keep));
                        keep="";

                    }
                }

            }
            index++;
            if (index>=expression.length()){
                break;
            }
        }
        //扫描完毕直接运算
        while (true){
            if (nums.isEmpty()){
                break;
            }
            a=nums.pop();
            b=nums.pop();
            oper=cal1.pop();
            res = nums.cal(a, b, oper);
            cal1.push(res);
        }
        int res1= cal1.pop();
        System.out.printf("最后的结果就是%d\n",res1);
    }
}

class ArrayStack1{
    private int maxSize;//栈的大小
    private int[] stack;//数组模拟栈，数据就存放在该数组中
    private int top=-1;//top表示栈顶，初始化为-1；
    public ArrayStack1(int maxSize){
        this.maxSize=maxSize;
        stack = new int[this.maxSize];
    }
    //增加一个方法可以返回当前栈的值，但并不是真正取出的真正的值
    public int peek(){
        return stack[top];
    }
    //栈满
    public boolean isFull(){
        return top==maxSize-1;
    }
    //栈空
    public boolean isEmpty(){
        return top == -1;
    }
    //入栈--push
    public void push(int value){
        //先判断栈是否满了
        if (isFull()){
            System.out.printf("栈满");
            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.printf("没有数据！");
            return;
        }
        for (int i = top;i>=0;i--){
            System.out.println("输出的数据是"+stack[i]);
        }
    }
    //判断优先级
    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=='/';
    }
    //计算的方法
    public int cal(int a,int b,int oper){
        int res = 0;
        switch (oper){
            case '+':
                res = a+b;
                break;
            case '-':
                res=b-a;
                break;
            case '*':
                res=a*b;
                break;
            case '/':
                res=b/a;
                break;
            default:
                break;
        }
        return res;
    }
}