数据结构 栈

package com.数据结构;

import java.util.Scanner;

public class 栈 {
    public static void main(String[] args){
        boolean flag = true ;
        Stack stack = new Stack(5);
        Scanner sc = new Scanner(System.in);
        while(flag){
            System.out.println("p 表示入栈");
            System.out.println("P 表示出栈");
            System.out.println("l 表示遍历栈");
            System.out.println("k 表示获取栈顶元素");
            System.out.println("e 表示退出程序");
            char ch = sc.next().charAt(0);
            switch (ch){
                case 'p':{
                    int value = sc.nextInt();
                    try{
                        stack.push(value);
                    }catch (Exception e){
                        System.out.println(e.getMessage());
                    }
                    break;
                } case 'P':{
                    try{
                        System.out.println(stack.pop());
                    }catch (Exception e){
                        System.out.println(e.getMessage());
                    }
                    break;
                } case 'l':{
                    stack.list();
                    break;
                } case 'k':{
                    System.out.println(stack.peek());
                    break;
                } case 'e':{
                    flag = false ;
                    sc.close();
                    break;
                }
            }
        }
    }
}
class Stack{
    private int[] data ; //数组模拟栈
    private int length ; //栈的容量
    private int top = -1 ; //栈顶指针
    public Stack(int length){
        this.length = length ;
        data = new int[length]  ;
    }
    public void push(int data){ //入栈
        if(isFull()){ //判断是满了
            throw new RuntimeException("栈已满");
        }
        this.data[++top] = data ;
    }
    public int pop(){ //出栈
        if(isEmpty()){ //判断是否为空
            throw new RuntimeException("栈是空的");
        }
        int value = data[top--] ;
        return value ;
    }
    public boolean isFull(){ //是否是满的
        return top == this.length-1;
    }
    public boolean isEmpty(){//是否是空的
        return top == -1;
    }
    public int peek(){ //窥视 获取栈顶元素但不弹出
        return data[top];
    }
    public void list(){ //遍历栈
        for(int i=this.top-1;i>=0;i--){
            System.out.println(data[i]);
        }
    }
}

用栈计算中缀表达式 只含加减乘除的运算:

package com.数据结构;

import java.util.Scanner;

public class 栈_简易计算器 { //中缀表达式 只含加减乘除的运算
    public static void main(String[] srgs){
        Scanner sc = new Scanner(System.in);
        String str = sc.next();
        Stack1 num = new Stack1(10); //储存数字
        Stack1 ope = new Stack1(10);//储存运算符
        int index = 0;
        for(index = 0;index<str.length();){
            if(!ope.isOpe(str.substring(index,index+1).charAt(0))){ //这个位置不是运算符
                int i = 1;
                String temp = str.substring(index,index+1);
                while(index+i<str.length()&&!ope.isOpe(str.substring(index+i,index+i+1).charAt(0))){ //这些位置都是数字
                    temp+=str.substring(index+i,index+i+1);
                    i++;
                }
                index+=i;
                num.push(Integer.parseInt(temp));
            }else{ //运算符
                if(ope.isEmpty()){ //栈是空的 直接入栈
                    ope.push((int)str.substring(index,index+1).charAt(0));
                }else{
                    int pri1 = ope.pri(str.substring(index,index+1).charAt(0));
                    int pri0 = ope.pri((char)ope.peek());
                    if(pri1<=pri0){
                        int num1 = num.pop();
                        int num2 = num.pop();
                        int operr= ope.pop();
                        int ans = num.cal(num1,num2,(char)operr);
                        num.push(ans);
                        ope.push((int)str.substring(index,index+1).charAt(0));
                    }else{
                        ope.push((int)str.substring(index,index+1).charAt(0));
                    }
                }
                index++;
            }
        }
        while(!ope.isEmpty()){
            int num1 = num.pop();
            int num2 = num.pop();
            int oppp = ope.pop();
            int ans = num.cal(num1,num2,(char)oppp);
            num.push(ans);
        }
        num.list();
        sc.close();
    }
}
class Stack1{
    private int[] data ; //数组模拟栈
    private int length ; //栈的容量
    private int top = -1 ; //栈顶指针
    public Stack1(int length){
        this.length = length ;
        data = new int[length]  ;
    }
    public void push(int data){ //入栈
        if(isFull()){ //判断是满了
            throw new RuntimeException("栈已满");
        }
        this.data[++top] = data ;
    }
    public int pop(){ //出栈
        if(isEmpty()){ //判断是否为空
            throw new RuntimeException("栈是空的");
        }
        int value = data[top--] ;
        return value ;
    }
    public boolean isFull(){ //是否是满的
        return top == this.length-1;
    }
    public boolean isEmpty(){//是否是空的
        return top == -1;
    }
    public int peek(){ //窥视 获取栈顶元素但不弹出
        return data[top];
    }
    public void list(){ //遍历栈
        for(int i=this.top;i>=0;i--){
            System.out.println(data[i]);
        }
    }
    public int pri(char ch){ //获取运算符的优先级 假设只有加减乘除
        if(ch=='+'||ch=='-')
            return 0;
        else
            return 1;
    }
    public boolean isOpe(char ch){ //判断是否是运算符
        if(ch=='+'||ch=='-'||ch=='*'||ch=='/')
            return true ;
        return false;

    }
    public int cal(int num1,int num2,char ope) { //计算两个数的运算结果
        int ans = 0;
        if (ope == '+') {
            return num1 + num2;
        } else if (ope == '-') {
            return num2 - num1;
        } else if (ope == '*') {
            return num1 * num2;
        } else  {
            return num2 / num1;
        }
    }
}

package com.数据结构;

import java.util.*;
import java.util.Stack;

public class 栈_逆波兰计算器 {
    //一 :将中缀表达式转变为后缀表达式
    //二 :利用栈计算逆波兰表达式
    //例如: (3+4)×5-6 对应的后缀表达式就是 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 void main(String[] args){
        System.out.println("请输入需要计算的中缀表达式");
        Scanner sc = new Scanner(System.in);
        String str = sc.next(); //读入中缀表达式

        List<String> list = toList(str);     //为了方便 我们把中缀表达式存在ArrayList中

        List<String> list1=ok(list);  //得到储存后缀表达式的List集合



        Stack<String> stack = new java.util.Stack<>();

        for(String s : list1) {
            if(s.matches("\d+")){ //含一位之上的数字 这里我们用了正则表达式 简化了代码
               stack.push(s);
            }else{ //运算符
                int num1 = Integer.valueOf(stack.pop());
                int num2 = Integer.valueOf(stack.pop());
                char ope  = s.charAt(0);
               stack.push(String.valueOf(math(num1,num2,ope)));
            }
        }
        System.out.println(stack.pop());
    }
    public static List<String> ok(List<String > list){ //把list集合中的中缀表达式变为后缀表达式

        Stack<String> s1 = new Stack<>(); //储存运算符
        List<String>  s2 = new ArrayList<>();//因为整个过程中 s2并没有pop数据 而且我们最后需要逆序输出 所以我们直接用List集合储存

        for(String t : list){
            if(t.matches("\d+")){ //该元素是数字
                s2.add(t);
            }else if(s1.isEmpty()||s1.peek().equals("(")){ //栈顶元素是( 或者栈空 直接入栈
                s1.push(t);
            }else if(t.equals("(")){//左括号
                s1.push(t);
            }else if(t.equals(")")){ // 右括号
                while(!s1.peek().equals("(")){
                    s2.add(s1.pop());
                }
                s1.pop();
            }else if(nb(t)>nb(s1.peek())){ //优先级比栈顶元素高
                s1.push(t);
            }else{
                s2.add(s1.pop());
                while(s1.size()!=0&&nb(t)<=nb(s1.peek())){
                    s2.add(s1.pop());
                }
                s1.push(t);
            }
        }
        while(s1.size()!=0){
            s2.add(s1.pop());
        }
        return s2 ;
    }
    public static List<String> toList(String str) { //将字符串存到List集合里
        List<String> list = new ArrayList<String>();
        int index = 0;
        String temp = "";
        while (index < str.length()) {
            temp = str.substring(index, index + 1);
            if (str.substring(index, index + 1).charAt(0) < '0' || str.substring(index, index + 1).charAt(0) > '9') { //运算符
                list.add(str.substring(index, index + 1));
            } else {
                int i = 1;
                while (index + i < str.length() && str.substring(index + i, index + i + 1).charAt(0) >= '0' && str.substring(index + i, index + i + 1).charAt(0) <= '9') {
                    temp += str.substring(index + i, index + i + 1);
                    i++;
                }
                list.add(temp);
                temp = "";
                index += i - 1;
            }
            index++;
        }
        return list ;
    }
    public static int nb(String str){ //获取运算符的优先级
        switch (str){
            case "+":
            case "-":
                return 1;
            case "*":
            case "/":
                return 2;
        }
        return 0;
    }
    public static int math(int a,int b,char c){
        if(c=='+'){
            return a+b;
        }else if(c=='*'){
            return a*b;
        }else if(c=='/'){
            return b/a;
        }else if(c=='-'){
            return b-a;
        }else{
            throw new RuntimeException("运算符有误~~~");
        }
    }
}