zl的六七周作业补交

group24/798277403/out/production/zhouliang/litestruts/struts.xml

@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<struts>
+    <action name="login" class="litestruts.LoginAction">
+        <result name="success">/jsp/homepage.jsp</result>
+        <result name="fail">/jsp/showLogin.jsp</result>
+    </action>
+    <action name="logout" class="litestruts.LogoutAction">
+    	<result name="success">/jsp/welcome.jsp</result>
+    	<result name="error">/jsp/error.jsp</result>
+    </action>
+</struts>

group24/798277403/src/basic/stack/expr/InfixExpr.java

@@ -0,0 +1,70 @@
+package basic.stack.expr;
+
+import java.util.List;
+import java.util.Stack;
+
+/**
+ * 中缀表达式求值
+ */
+public class InfixExpr {
+	String expr = null;
+
+	public InfixExpr(String expr) {
+		this.expr = expr;
+	}
+
+	public float evaluate() {
+        TokenParser parser = new TokenParser();
+        List<Token> tokens = parser.parse(this.expr);
+
+
+        Stack<Token> opStack = new Stack<>();
+        Stack<Float> numStack = new Stack<>();
+
+        for(Token token : tokens){
+
+            if (token.isOperator()){
+                //当运算符栈不为空，并且当前的操作符优先级不比栈顶操作符优先级高时，弹出栈顶操作符进行运算
+                while(!opStack.isEmpty()
+                        && !token.hasHigherPriority(opStack.peek())){
+                    Token prevOperator = opStack.pop();
+                    Float f2 = numStack.pop();
+                    Float f1 = numStack.pop();
+                    Float result = calculate(prevOperator.toString(), f1,f2);
+                    numStack.push(result);
+                }
+                opStack.push(token);
+            }
+            if(token.isNumber()){
+                numStack.push(new Float(token.getIntValue()));
+            }
+        }
+
+        while(!opStack.isEmpty()){
+            Token token = opStack.pop();
+            Float f2 = numStack.pop();
+            Float f1 = numStack.pop();
+            numStack.push(calculate(token.toString(), f1,f2));
+        }
+
+
+        return numStack.pop().floatValue();
+	}
+
+    private Float calculate(String op, Float f1, Float f2){
+        if(op.equals("+")){
+            return f1+f2;
+        }
+        if(op.equals("-")){
+            return f1-f2;
+        }
+        if(op.equals("*")){
+            return f1*f2;
+        }
+        if(op.equals("/")){
+            return f1/f2;
+        }
+        throw new RuntimeException(op + " is not supported");
+    }
+
+}

group24/798277403/src/basic/stack/expr/InfixExprTest.java

@@ -0,0 +1,51 @@
+package basic.stack.expr;
+
+import org.junit.After;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+
+
+public class InfixExprTest {
+
+	@Before
+	public void setUp() throws Exception {
+	}
+
+	@After
+	public void tearDown() throws Exception {
+	}
+
+	@Test
+	public void testEvaluate() {
+		//InfixExpr expr = new InfixExpr("300*20+12*5-20/4");
+		{
+			InfixExpr expr = new InfixExpr("2+3*4+5");
+			Assert.assertEquals(19.0, expr.evaluate(), 0.001f);
+		}
+		{
+			InfixExpr expr = new InfixExpr("3*20+12*5-40/2");
+			Assert.assertEquals(100.0, expr.evaluate(), 0.001f);
+		}
+
+		{
+			InfixExpr expr = new InfixExpr("3*20/2");
+			Assert.assertEquals(30, expr.evaluate(), 0.001f);
+		}
+		{
+			InfixExpr expr = new InfixExpr("20/2*3");
+			Assert.assertEquals(30, expr.evaluate(), 0.001f);
+		}
+
+		{
+			InfixExpr expr = new InfixExpr("10-30+50");
+			Assert.assertEquals(30, expr.evaluate(), 0.001f);
+		}
+		{
+			InfixExpr expr = new InfixExpr("10-2*3+50");
+			Assert.assertEquals(54, expr.evaluate(), 0.001f);
+		}
+
+	}
+
+}

group24/798277403/src/basic/stack/expr/InfixToPostfix.java

@@ -0,0 +1,75 @@
+package basic.stack.expr;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Stack;
+
+public class InfixToPostfix {
+
+	public static List<Token> convert(String expr) {
+		List<Token> inFixTokens = new TokenParser().parse(expr);
+		List<Token> postFixTokens = new ArrayList<>();
+		Stack<Token> opStack = new Stack<Token>();
+
+		for(Token token : inFixTokens){
+			if(token.isNumber()){
+				postFixTokens.add(token);
+			}
+			if(token.isOperator()){
+				while(!opStack.isEmpty() && !token.hasHigherPriority(opStack.peek())){
+					postFixTokens.add(opStack.pop());
+				}
+				opStack.push(token);
+			}
+			if(token.toString().equals("(")){
+				opStack.push(token);
+			}
+			if(token.toString().equals(")")){
+				while(!opStack.peek().value.equals(")")){
+					postFixTokens.add(opStack.pop());
+				}
+				opStack.pop();
+			}
+		}
+		while(!opStack.isEmpty()){
+			postFixTokens.add(opStack.pop());
+		}
+		return postFixTokens;
+	}
+
+
+	public static List<Token> convert1(String expr) {
+		List<Token> inFixTokens = new TokenParser().parse(expr);
+
+		List<Token> postFixTokens = new ArrayList<>();
+
+		Stack<Token> opStack = new Stack<Token>();
+		for(Token token : inFixTokens){
+
+			if(token.isOperator()){
+
+				while(!opStack.isEmpty()
+						&& !token.hasHigherPriority(opStack.peek())){
+					postFixTokens.add(opStack.pop());
+
+				}
+				opStack.push(token);
+
+			}
+			if(token.isNumber()){
+
+				postFixTokens.add(token);
+
+			}
+		}
+
+		while(!opStack.isEmpty()){
+			postFixTokens.add(opStack.pop());
+		}
+
+		return postFixTokens;
+	}
+
+
+
+}

group24/798277403/src/basic/stack/expr/InfixToPostfixTest.java

@@ -0,0 +1,41 @@
+package basic.stack.expr;
+
+import org.junit.After;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+
+import java.util.List;
+
+
+
+public class InfixToPostfixTest {
+
+	@Before
+	public void setUp() throws Exception {
+	}
+
+	@After
+	public void tearDown() throws Exception {
+	}
+
+	@Test
+	public void testConvert() {
+		{
+			List<Token> tokens = InfixToPostfix.convert("2+3");
+			Assert.assertEquals("[2, 3, +]", tokens.toString());
+		}
+		{
+
+			List<Token> tokens = InfixToPostfix.convert("2+3*4");
+			Assert.assertEquals("[2, 3, 4, *, +]", tokens.toString());
+		}
+
+		{
+
+			List<Token> tokens = InfixToPostfix.convert("2-3*4+5");
+			Assert.assertEquals("[2, 3, 4, *, -, 5, +]", tokens.toString());
+		}
+	}
+
+}

group24/798277403/src/basic/stack/expr/PostfixExpr.java

@@ -0,0 +1,60 @@
+package basic.stack.expr;
+
+import java.util.List;
+import java.util.Stack;
+
+public class PostfixExpr {
+String expr = null;
+
+	public PostfixExpr(String expr) {
+		this.expr = expr;
+	}
+
+	public float evaluate() {
+		TokenParser parser = new TokenParser();
+		List<Token> tokens = parser.parse(this.expr);
+
+		Stack<Token> opStack = new Stack<>();
+		Stack<Float> numStack = new Stack<>();
+		for(Token token : tokens){
+			if(token.isNumber()){
+				numStack.push(new Float(token.getIntValue()));
+			}
+			if(token.isOperator()){
+				if(numStack.size()>=2){
+					Float f2 = numStack.pop();
+					Float f1 = numStack.pop();
+					Float result = calculate(token.toString(), f1,f2);
+					numStack.push(result);
+				}else{
+					opStack.push(token);
+				}
+			}
+		}
+
+		while(!opStack.isEmpty()){
+			Token token = opStack.pop();
+			Float f2 = numStack.pop();
+			Float f1 = numStack.pop();
+			Float result = calculate(token.toString(), f1,f2);
+			numStack.push(result);
+		}
+		return numStack.pop().floatValue();
+	}
+
+	private Float calculate(String op, Float f1, Float f2){
+		if(op.equals("+")){
+			return f1+f2;
+		}
+		if(op.equals("-")){
+			return f1-f2;
+		}
+		if(op.equals("*")){
+			return f1*f2;
+		}
+		if(op.equals("/")){
+			return f1/f2;
+		}
+		throw new RuntimeException(op + " is not supported");
+	}
+}

group24/798277403/src/basic/stack/expr/PostfixExprTest.java

@@ -0,0 +1,41 @@
+package basic.stack.expr;
+
+
+
+import org.junit.After;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+
+
+
+public class PostfixExprTest {
+
+	@Before
+	public void setUp() throws Exception {
+	}
+
+	@After
+	public void tearDown() throws Exception {
+	}
+
+	@Test
+	public void testEvaluate() {
+		{
+			PostfixExpr expr = new PostfixExpr("6 5 2 3 + 8 * + 3 + *");
+			Assert.assertEquals(288, expr.evaluate(),0.0f);
+		}
+		{
+			//9+(3-1)*3+10/2
+			PostfixExpr expr = new PostfixExpr("9 3 1-3*+ 10 2/+");
+			Assert.assertEquals(20, expr.evaluate(),0.0f);
+		}
+
+		{
+			//10-2*3+50
+			PostfixExpr expr = new PostfixExpr("10 2 3 * - 50 +");
+			Assert.assertEquals(54, expr.evaluate(),0.0f);
+		}
+	}
+
+}