栈实现简易计算功能

Bertha 。 2021-08-11 22:17 388阅读 0赞

【一】栈实现计算功能思想

> 1.首先定义两个栈，数据栈numStack、符号栈operStack  
> 2.如果扫描到的是一个数字就存入numStack中  
> 3.如果扫描到的是一个符号
> 
> 1.  如果符号栈为空，直接加入符号；
> 2.  如果操作的符号优先级小于等于符号栈中的符号，从符号栈中pop出一个符号，再从数据栈中pop出两个数据，进行运算并将运算结果存入数据栈中；
> 3.  如果操作的符号优先级大于栈中的符号，直接存储；
> 
> 4.当扫描完毕，数据栈中栈底的元素为运算结果

【二】代码实现

import java.util.Scanner;
    public class Calculator {
    	public static void main(String[] args) {
    		Scanner sc=new Scanner(System.in);
    		ArrayStack numStack=new ArrayStack(10);
    		ArrayStack operStack=new ArrayStack(10);
    		String expr=sc.nextLine();
    		
    		int index=0;//定义扫描的索引
    		int num1=0;
    		int num2=0;
    		int oper=0;//操作符
    		int res=0;
    		char ch=' ';//将每次扫描得到的char保存在ch中
    		String keepNum="";
    		while(true) {
    			//得到表达式的每一个字符
    			ch=expr.substring(index,index+1).charAt(0);
    			if(operStack.isOper(ch)) {
    				if(!operStack.isEmpty()) {
    					//栈不为空，比较运算符的优先级
    					if(operStack.priority(ch)<=operStack.priority(operStack.peek())) {
    						oper=operStack.pop();
    						num1=numStack.pop();
    						num2=numStack.pop();
    						res=numStack.cal(num1, num2, (char)oper);
    						numStack.push(res);
    						operStack.push(ch);
    					}else {
    						//如果操作的符号优先级大于栈中的符号，直接存储；
    						operStack.push(ch);
    					}
    				}else {
    					//对应的栈为空
    					operStack.push(ch);
    				}
    			}else {
    				//此处需注意，不能一确定是数字就存入栈中，应注意多位数据的情况
    				keepNum+=ch;
    				if(index==expr.length()-1) {
    					numStack.push(Integer.parseInt(keepNum));
    					
    				}else {
    					if(operStack.isOper(expr.substring(index+1,index+2).charAt(0))) {
    						numStack.push(Integer.parseInt(keepNum));
    						keepNum="";
    					}
    				}
    			}
    			index++;
    			if(index>=expr.length()) {
    				break;
    			}
    		}
    			//当扫描完毕，就顺序的从数栈和符号栈中pop出相应的数据和符号，进行运算
    		while(true) {
    			if(operStack.isEmpty()) {
    				break;
    			}
    			num1=numStack.pop();
    			num2=numStack.pop();
    			oper=operStack.pop();
    			res=numStack.cal(num1, num2, oper);
    			numStack.push(res);
    		}
    		System.out.printf("表达式%s=%d",expr,numStack.pop());
    	}
    }
    
    class ArrayStack{
    	private int maxSize;
    	private int[] arr;
    	private int top=-1;
    	
    	//初始化
    	ArrayStack(int maxSize){
    		this.maxSize=maxSize;
    		arr=new int[this.maxSize];
    	}
    	
    	//返回栈顶的元素
    	public int peek() {
    		return arr[top];
    	}
    	//判断栈是否为空
    	public boolean isEmpty() {
    		return top==-1;
    	}
    	
    	//判断栈是否已满
    	public boolean isFull() {
    		return top>maxSize-1;
    	}
    	
    	//入栈
    	public void push(int num) {
    		if(isFull()) {
    			System.out.println("栈满~");
    			return;
    		}
    		top++;
    		arr[top]=num;
    	}
    	
    	//出栈
    	public int pop() {
    		if(isEmpty()) {
    			throw new RuntimeException("栈为空");
    		}
    		int num=arr[top];
    		top--;
    		return num;
    	}
    	
    	//显示栈即遍历栈
    	public void listStack() {
    		if(isEmpty()) {
    			System.out.println("栈为空");
    			return ;
    		}
    		for(int i=top;i>=0;i--) {
    			System.out.print(arr[i]+"   ");
    		}
    	}
    	
    	//优先级的比较
    	public int priority(int oper) {
    		if(oper=='*'||oper=='/') {
    			return 1;
    		}else if(oper=='+'||oper=='-') {
    			return 0;
    		}else {
    			return -1;
    		}
    	}
    	
    	//判断是不是一个操作符
    	public boolean isOper(char oper) {
    		return oper=='*'||oper=='/'||oper=='+'||oper=='-';
    	}
    	
    	//计算方法
    	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;
    			
    		}
    		return res;
    	}
    }

【三】输出截图

![20190912182958414.png][]

[20190912182958414.png]: /images/20210811/4de8b0b0027d4d8591b81265b7c5d81f.png