数据结构之计算器的实现（JAVA）（四）

   原理：

       1.将中序表达式变化后续表达式

       2.当前字符为数字，将该数字放入栈中

       3.当前字符为操作符，从栈中取出两个树，根据操作符来运算，将运算结果放入到栈中

       4.重复，直到将字符操作完，此时栈中只剩下一个元素，即要运算的结果

   PS：我没有处理，只可以运行10以内的运算，如果有需要可以扩展
      

package com.lip.datastructure.tree;

import java.util.Iterator;
import java.util.Stack;

public class Calculator
	{

		public static void main(String[] args)
			{
				String obj = "a*(b+c)+c/d";
				String obj1 = "2*(1+3)+9/3";
				
				System.out.println(obj1+"="+calculator(obj1));

			}
		//利用后序表达式计算
		///原理：1.当期字符为字母或者数字，则直接入栈
		//      2.当前字符为操作符则从栈中取出两个数字计算
		//      3.将计算结果再放入到栈中，栈中最后剩余的一个元素就是要求的结果
		public static int calculator(String obj)
		{
			String postObj=tranform(obj);
			System.out.println();
			Stack<Integer>stack=new Stack<Integer>();
			for(int i=0;i<postObj.length();i++)
				{
					char ch=postObj.charAt(i);
					if(Character.isLetterOrDigit(ch))//字符或者数字
						{
							stack.push(Integer.parseInt(ch+""));
						}
					else//操作符
						{
							//取出两个数
							int op1,op2;
							op1=stack.pop();
							op2=stack.pop();
							switch (ch)
								{
								case '+':
									stack.push(op2+op1);
									break;
								case '-':
									stack.push(op2-op1);
									break;
								case '*':
									stack.push(op2*op1);
									break;
								case '/':
									stack.push(op2/op1);
									break;
								default:
									break;
								}
						}
				}
			return stack.pop();
		}
		// 中序遍历改为后续遍历
		public static String tranform(String obj)
			{
				Stack<Character> stack = new Stack<Character>();
				String obj2 = "";
				for (int i = 0; i < obj.length(); i++)
					{
						char ch = obj.charAt(i);
						if (Character.isLetterOrDigit(ch))// 字母或数字直接输出
							{
								obj2 += ch;
								System.out.print(ch);
							} else if (ch == ')')// 在栈中一致匹配到)操作符才停止出栈
							{
								char temp;
								while ((temp = stack.pop()) != '(')
									{
										obj2 += temp;
										System.out.print(temp);
									}
							} else
							// 比较操作符的进栈优先级
							{
								if (stack.isEmpty())
									{
										stack.push(ch);
										continue;
									}
								char temp = stack.peek();
								while (icp(ch) <= isp(temp))// 进栈优先级小于栈内优先级，则一直出栈
									{
										System.out.print(temp);
										obj2 += temp;
										stack.pop();
										if (stack.isEmpty())
											break;
										temp = stack.peek();
									}
								stack.push(ch);
							}
					}
				// 将栈中剩余的元素弹出来
				while (!stack.isEmpty())
					{
						char temp = stack.pop();
						obj2 += temp;
						System.out.print(temp);
					}
				return obj2;
			}
		// 操作符在栈内的优先级
				private static int isp(char ch)
					{
						switch (ch)
							{
							case '+':
							case '-':
								return 2;
							case '*':
							case '/':
								return 4;
							case ')':
								return 7;
							case '(':
								return 1;
							default:
								break;
							}
						return 0;
					}

				// 操作符进栈的优先级优先级
				private static int icp(char ch)
					{
						switch (ch)
							{
							case '+':
							case '-':
								return 3;
							case '*':
							case '/':
								return 5;
							case ')':
								return 1;
							case '(':
								return 7;
							default:
								break;
							}
						return 0;
					}

	}