程序或思路

[godismydaughter]

有一字符串 12＋26*3/6-39+9*32 求该字符串的运算结果。

程序或思路都可以。

[SambaGao]

[Quote=引用 2 楼 ark032425 的回复:]

用正则表达式；
先算成 匹配 [数字*数字]； 计算出结果 把 刚才的 [数字*数字] 用结果替换掉
再算除法；匹配 [数字/数字]； 计算出结果 把 刚才的 [数字/数字] 用结果替换掉
再算加法;最后算减法
[/Quote]

只能取出来一个一个的判断了

[不姓贾_请叫我甄先生]

[Quote=引用 4 楼 nihaozhangchao 的回复:]
引用 2 楼 ark032425 的回复:

用正则表达式；
先算成 匹配 [数字*数字]； 计算出结果 把 刚才的 [数字*数字] 用结果替换掉
再算除法；匹配 [数字/数字]； 计算出结果 把 刚才的 [数字/数字] 用结果替换掉
再算加法;最后算减法


只能取出来一个一个的判断了
[/Quote]
也只能这样……

[gaoxulaiguo]

[Quote=引用 2 楼 ark032425 的回复:]
用正则表达式；
先算成 匹配 [数字*数字]； 计算出结果 把 刚才的 [数字*数字] 用结果替换掉
再算除法；匹配 [数字/数字]； 计算出结果 把 刚才的 [数字/数字] 用结果替换掉
再算加法;最后算减法
[/Quote]
用IF判断也一样的，只有四个符号而已

[Dazzlingwinter]

//简单模拟实现
import java.util.Arrays;
import java.util.Stack;

public class CalcExpress {
	public static void main(String[] args) {
		String calcString = "12+26*3/6-39+9*32";
		String[] nArray = calcString.split("[^0-9]");
		String[] oArray = calcString.split("[^\\+\\-\\*\\/]{1,}");
		System.out.println("Nums:\t\t\t\t\t" + Arrays.toString(nArray));
		System.out.println("Opts:\t\t\t\t\t" + Arrays.toString(oArray));
		
		Stack<String> stack = new Stack<String>();
		for(int i=0; i<nArray.length;) {
			stack.push(nArray[i++]);
			if(i < oArray.length)	stack.push(oArray[i]);
		}
		
		System.out.println("DataInStack:\t\t\t\t" + stack);
		
		Stack<String> tempStack = new Stack<String>();
		
		calcPlusDivide(stack, tempStack);
		calcAddDec(tempStack);
		
		System.out.println("FinalResult:\t\t\t\t" + tempStack);
	}
	
	public static void calcAddDec(Stack<String> stack) {		
		if(!stack.isEmpty()) {
			System.out.println("AddOrDec:\t\t\t\t" + stack);
			String tempStr = stack.pop();
			if(!stack.isEmpty()) {
				String opt = stack.pop();
				Double result = "+".equals(opt) ? Double.valueOf(tempStr) + Double.valueOf(stack.pop()) : Double.valueOf(tempStr) - Double.valueOf(stack.pop());
				stack.push(String.valueOf(result));
				calcAddDec(stack);
			}else {
				stack.push(tempStr);
			}
		}
	}
	
	public static void calcPlusDivide(Stack<String> stack, Stack<String> tempStack) {		
		if(!stack.isEmpty()) {
			System.out.println("PlusOrDiv:\t\t\t\t" + stack + "\t\t\t\t" + tempStack);
			String tempStr = stack.pop();
			if("*".equals(tempStr) || "/".equals(tempStr)) {
				String strA = stack.pop();
				String strB = tempStack.pop();
				Double result = "*".equals(tempStr) ? Double.valueOf(strA) * Double.valueOf(strB) : Double.valueOf(strA) / Double.valueOf(strB);
				tempStack.push(String.valueOf(result));
			}else {
				tempStack.push(tempStr);				
			}
			calcPlusDivide(stack, tempStack);
		}
	}
}
/*
Nums:					[12, 26, 3, 6, 39, 9, 32]
Opts:					[, +, *, /, -, +, *]
DataInStack:				[12, +, 26, *, 3, /, 6, -, 39, +, 9, *, 32]
PlusOrDiv:				[12, +, 26, *, 3, /, 6, -, 39, +, 9, *, 32]				[]
PlusOrDiv:				[12, +, 26, *, 3, /, 6, -, 39, +, 9, *]				[32]
PlusOrDiv:				[12, +, 26, *, 3, /, 6, -, 39, +]				[288.0]
PlusOrDiv:				[12, +, 26, *, 3, /, 6, -, 39]				[288.0, +]
PlusOrDiv:				[12, +, 26, *, 3, /, 6, -]				[288.0, +, 39]
PlusOrDiv:				[12, +, 26, *, 3, /, 6]				[288.0, +, 39, -]
PlusOrDiv:				[12, +, 26, *, 3, /]				[288.0, +, 39, -, 6]
PlusOrDiv:				[12, +, 26, *]				[288.0, +, 39, -, 0.5]
PlusOrDiv:				[12, +]				[288.0, +, 39, -, 13.0]
PlusOrDiv:				[12]				[288.0, +, 39, -, 13.0, +]
AddOrDec:				[288.0, +, 39, -, 13.0, +, 12]
AddOrDec:				[288.0, +, 39, -, 25.0]
AddOrDec:				[288.0, +, -14.0]
AddOrDec:				[274.0]
FinalResult:				[274.0]
*/

[guoliang2010]

记得 有个 后缀表达式，利用堆栈来计算，应该是种思路。

[doudou]

import java.util.*;

public class CaculateStr {
	private static String[] s = { "+", "-", "*", "/" };
	// +,-,*,/的优先级比对表
	private static String[][] tabel = { { "<", "<", ">", ">" },
			{ "<", "<", ">", ">" }, { "<", "<", "<", "<" },
			{ "<", "<", "<", "<" } };

	public static String compareLevel(String a, String b) {
		int row = 0;
		int col = 0;
		for (int i = 0; i < 4; i++)
			if (s[i].equals(a))
				col = i;
		for (int i = 0; i < 4; i++)
			if (s[i].equals(b))
				row = i;
		return tabel[row][col];
	}

	public static float caculate(String s) {
		try {
			boolean flag = false;// 起标识作用，决定该不该取出numbers众的数字入num_stack栈
			StringTokenizer st = new StringTokenizer(s, "+-*/");
			// 存放所有的参与运算的数字
			List<Float> numbers = new ArrayList<Float>();
			// 存放所有的运算符
			List<String> symbols = new ArrayList<String>();
			// 数字栈
			Stack<Float> num_stack = new Stack<Float>();
			// 运算符栈
			Stack<String> sym_stack = new Stack<String>();

			// 逐个把参与运算的数字存储到numbers里面
			while (st.hasMoreTokens()) {
				numbers.add(Float.parseFloat(st.nextToken()));
			}
			// 逐个把运算符存储到symbols里面
			for (int i = 0; i < s.length(); i++) {
				String temp = s.substring(i, i + 1);
				if (temp.equals("+") || temp.equals("-") || temp.equals("*")
						|| temp.equals("/")) {
					symbols.add(temp);
				}
			}
			// 满足一下条件之一继续执行
			// 符号栈没有空、数字栈栈内元素多于一个、numbers没有空、symbols没有空
			while (sym_stack.isEmpty() == false || num_stack.size() > 1
					|| numbers.isEmpty() == false || symbols.isEmpty() == false) {
				// flag为false从numbers中取第一个数字 入num_stack栈
				if (flag == false) {
					num_stack.add(numbers.get(0));
					numbers.remove(0);
				}
				// 如果符号栈为空，从symbols中取第一个运算符如入sym_stack栈
				// 并从numbers中取第一个数字 入num_stack栈
				if (sym_stack.isEmpty()) {
					sym_stack.add(symbols.get(0));
					symbols.remove(0);
					num_stack.add(numbers.get(0));
					numbers.remove(0);
				}

				// 运算符用完 或者
				// 后面一个运算符优先级小于运算符栈顶元素的优先级，如：“-”的优先级小于“*”
				// 取出数字栈栈顶两个数进行运算
				if (symbols.isEmpty()
						|| compareLevel(symbols.get(0),
								sym_stack.get(sym_stack.size() - 1))
								.equals("<")) {
					flag = true;
					Float a = num_stack.get(num_stack.size() - 1);
					num_stack.remove(num_stack.size() - 1);
					Float b = num_stack.get(num_stack.size() - 1);
					num_stack.remove(num_stack.size() - 1);
					String sym = sym_stack.get(sym_stack.size() - 1);
					sym_stack.remove(sym_stack.size() - 1);
					if (sym.equals("+")) {
						num_stack.add(b + a);
					} else if (sym.equals("-")) {
						num_stack.add(b - a);
					} else if (sym.equals("*")) {
						num_stack.add(b * a);
					} else if (sym.equals("/")) {
						num_stack.add(b / a);
					}
				} else {// 从symbols中取第一个运算符入sym_stack栈
					flag = false;
					sym_stack.add(symbols.get(0));
					symbols.remove(0);
				}
			}
			return num_stack.get(num_stack.size() - 1);
		} catch (Exception e) {
			System.out.println("检查输入字符串是否符合算术表达式标准！");
			e.printStackTrace();
			return 0f;
		}
	}

	public static void main(String[] args) {
		String s = "3*2+8/2*5/5+7-8";
		System.out.println(s + "=" + caculate(s));
	}
}//用堆栈做的

运行结果如下：
3*2+8/2*5/5+7-8=9.0

[doudou]

唉，楼主不够意思啊！我花了一个小时的时间做的，没分不要紧，我的方法也可以实现的，虽然不一定很好，但是至少大家还是拿来借鉴一下吧！不要浪费了我的心血哦！

[knightzhuwei]

http://topic.csdn.net/t/20040314/10/2840689.html
5楼

[Ark032425]

用正则表达式；
先算成 匹配 [数字*数字]； 计算出结果 把 刚才的 [数字*数字] 用结果替换掉
再算除法；匹配 [数字/数字]； 计算出结果 把 刚才的 [数字/数字] 用结果替换掉
再算加法;最后算减法

[xiaohuanjie]

[godismydaughter]

[Quote=引用 10 楼 doudou15223155621 的回复:]

唉，楼主不够意思啊！我花了一个小时的时间做的，没分不要紧，我的方法也可以实现的，虽然不一定很好，但是至少大家还是拿来借鉴一下吧！不要浪费了我的心血哦！
[/Quote]不好意思，结帖太快了。谢谢你的程序。