java去哪儿笔试解决方案四
2014-03-07 14:57
393 查看
请使用自己实现的stack，实现一个整型表达式求值的函数，表示式支持的运算符有（）*/+-具体说明如下
1.*/优先级高于+-
2.表达式中相同优先级的操作符自左向右计算
3.函数输入字符串"1+(4-3)*5/5",函数返回结果为2
使用api中stack
将前缀转为后缀
/**
* 中缀表达式 转 后缀表达式
*/
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Stack;
public class ExpressConvert {
/**
* 优先级比较
* @param operator1 比较值
* @param operator2 被比较值
* @return 小于等于返回false,大于返回true
*/
public boolean comparePrior(char operator1, char operator2) {
if('(' == operator2) {
return true;
}
if ('*' == operator1 || '/' == operator1) {
if ('+' == operator2 || '-' == operator2) {
return true;
}
}
return false;
}
/**
* 转为后缀表达式:
* 1、如果是"("直接压入stack栈。
* 2、如果是")"，依次从stack栈弹出运算符加到数组newExpressionStrs的末尾，知道遇到"("；
* 3、如果是非括号，比较扫描到的运算符，和stack栈顶的运算符。如果扫描到的运算符优先级高于栈顶运算符则，把运算符压入栈。否则的话，就依次把栈中运算符弹出加到数组newExpressionStrs的末尾，直到遇到优先级低于扫描到的运算符或栈空，并且把扫描到的运算符压入栈中。就这样依次扫描，知道结束为止。如果扫描结束，栈中还有元素，则依次弹出加到数组newExpressionStrs的末尾，就得到了后缀表达式。
* @param expressionStrs
* @return
*/
public List<Character> toSuffixExpression(char[] expressionStrs) {
//新组成的表达式
List<Character> newExpressionStrs = new ArrayList<Character>();
Stack<Character> stack = new Stack<Character>();
for (int i = 0; i < expressionStrs.length; i++) {
if ('('==(expressionStrs[i])) { // 如果是左括号,则入栈
stack.push(expressionStrs[i]);
} else if ('+'==expressionStrs[i] || '-' == expressionStrs[i] || '*' == expressionStrs[i] || '/' == expressionStrs[i]) {
if (!stack.empty()) { // 取出先入栈的运算符
Character s = stack.pop();
if(comparePrior(expressionStrs[i], s)) { //如果栈值优先级小于要入栈的值,则继续压入栈
stack.push(s);
} else { //否则取出值
newExpressionStrs.add(s);
}
}
stack.push(expressionStrs[i]);
} else if (')' == expressionStrs[i]) { //如果是')',则出栈,一直到遇到'('
while (!stack.empty()) {
char s = stack.pop();
if (!('(' == s)) {
newExpressionStrs.add(s);
} else {
break;
}
}
} else {
newExpressionStrs.add(expressionStrs[i]);
}
}
while (!stack.empty()) {
char s = stack.pop();
newExpressionStrs.add(s);
}
return newExpressionStrs;
}
public static void main(String[] args) {
String expressionStr = "5+(4-5+1)-4+(6-5+3)+2";
// 分割成表达式数组
char []expressionChrs = expressionStr.toCharArray();
List<Character> newExpressionStrs = new ExpressConvert().toSuffixExpression(expressionChrs);
Iterator<Character> iter = newExpressionStrs.iterator();
while(iter.hasNext()){
System.out.print(iter.next());
}
}
}
//用栈计算后缀表达式值
原理：将后缀表达只放在list中，或者数组
循环去除后缀表达式如果取出的为数字则push到stack中，如果是运算符，则将stack中的数值pop出来，用后pop出的数（+-*/）先pop出的数，然后将结果放回stack中
直到最后一个值pop出stack，即为所求
import java.util.Iterator;
import java.util.List;
import calculator.ExpressConvert;
import dataStructure.MyStack;
public class Test4 {
public static void main(String []args){
MyStack ms = new MyStack();
String str = "1+(4-3)*5/5";
char chr[] = str.toCharArray();
ExpressConvert ec = new ExpressConvert();
List<Character> list = ec.toSuffixExpression(chr);
Iterator<Character> iter = list.iterator();
while(iter.hasNext()){
Character c = iter.next();
try {
if(c=='+' || c == '-' || c == '*' || c == '/'){
int a = Integer.parseInt(ms.pop().toString());
int b = Integer.parseInt(ms.pop().toString());
int n = 0;
switch(c){
case '+':n=b+a;break;
case '-':n=b-a;break;
case '*':n=b*a;break;
case '/':n=b/a;break;
}
ms.push(n);
}else{
ms.push(c);
}
} catch (Exception e) {
// TODO Auto-generated catch block
<
4000
/span>e.printStackTrace();
}
}
System.out.println(ms.getSize());
try {
System.out.println(ms.pop());
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
} e.printStackTrace();
}
}
}
//自定义栈 （简单的） 欢迎吐槽
import java.util.ArrayList;
import java.util.List;
import java.util.Stack;
/**
* 数据结构 栈
* 使用数组实现
* @author Administrator
*
*/
public class MyStack<T> {
private int top ;//栈顶
private Object[] obj;
private int max=10;
private int size;//栈大小
public MyStack(){
this.obj = new Object[max];
}
public boolean empty(){
if(size == 0)
return true;
return false;
}
public T pop() throws Exception{
if(size==0) throw new Exception("下表越界");
Object objct = obj[top];
obj[top--] = null;
size --;
return (T)objct;
}
public T push(Object o) throws Exception{
if(size==max) throw new Exception("下标越界");
obj[++top] = o;
size ++;
return (T)obj[top];
}
public int getSize(){
return size;
}
public static void main(String []args){
MyStack ms = new MyStack();
try {
ms.push("aaa");
ms.push("bbb");
ms.push("ccc");
System.out.println(ms.pop()+" "+ms.pop());
System.out.println(ms.size);
System.out.println(1+(4-3)*5/5);
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
//使用自定义stack，前缀转中缀
/**
* 中缀表达式 转 后缀表达式
*/
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import dataStructure.MyStack;
public class ExpressConvert {
/**
* 优先级比较
* @param operator1 比较值
* @param operator2 被比较值
* @return 小于等于返回false,大于返回true
*/
public boolean comparePrior(char operator1, char operator2) {
if('(' == operator2) {
return true;
}
if ('*' == operator1 || '/' == operator1) {
if ('+' == operator2 || '-' == operator2) {
return true;
}
}
return false;
}
/**
* 转为后缀表达式:
* 1、如果是"("直接压入stack栈。
* 2、如果是")"，依次从stack栈弹出运算符加到数组newExpressionStrs的末尾，知道遇到"("；
* 3、如果是非括号，比较扫描到的运算符，和stack栈顶的运算符。如果扫描到的运算符优先级高于栈顶运算符则，把运算符压入栈。否则的话，就依次把栈中运算符弹出加到数组newExpressionStrs的末尾，直到遇到优先级低于扫描到的运算符或栈空，并且把扫描到的运算符压入栈中。就这样依次扫描，知道结束为止。如果扫描结束，栈中还有元素，则依次弹出加到数组newExpressionStrs的末尾，就得到了后缀表达式。
* @param expressionStrs
* @return
*/
public List<Character> toSuffixExpression(char[] expressionStrs){
//新组成的表达式
List<Character> newExpressionStrs = new ArrayList<Character>();
MyStack<Character> MyStack = new MyStack<Character>();
try {
for (int i = 0; i < expressionStrs.length; i++) {
if ('('==(expressionStrs[i])) { // 如果是左括号,则入栈
MyStack.push(expressionStrs[i]);
} else if ('+'==expressionStrs[i] || '-' == expressionStrs[i] || '*' == expressionStrs[i] || '/' == expressionStrs[i]) {
if (!MyStack.empty()) { // 取出先入栈的运算符
Character s = MyStack.pop();
if(comparePrior(expressionStrs[i], s)) { //如果栈值优先级小于要入栈的值,则继续压入栈
MyStack.push(s);
} else { //否则取出值
newExpressionStrs.add(s);
}
}
MyStack.push(expressionStrs[i]);
} else if (')' == expressionStrs[i]) { //如果是')',则出栈,一直到遇到'('
while (!MyStack.empty()) {
char s = MyStack.pop();
if (!('(' == s)) {
newExpressionStrs.add(s);
} else {
break;
}
}
} else {
newExpressionStrs.add(expressionStrs[i]);
}
}
while (!MyStack.empty()) {
char s = MyStack.pop();
newExpressionStrs.add(s);
}
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return newExpressionStrs;
}
public static void main(String[] args) {
String expressionStr = "5+(4-5+1)-4+(6-5+3)+2";
// 分割成表达式数组
char []expressionChrs = expressionStr.toCharArray();
List<Character> newExpressionStrs;
try {
newExpressionStrs = new ExpressConvert().toSuffixExpression(expressionChrs);
Iterator<Character> iter = newExpressionStrs.iterator();
while(iter.hasNext()){
System.out.print(iter.next());
}
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
//计算
public class Test4 {
public static void main(String []args){
MyStack ms = new MyStack();
String str = "1+(5-3)*5/5";
char chr[] = str.toCharArray();
ExpressConvert ec = new ExpressConvert();
List<Character> list = ec.toSuffixExpression(chr);
Iterator<Character> iter = list.iterator();
while(iter.hasNext()){
Character c = iter.next();
try {
if(c=='+' || c == '-' || c == '*' || c == '/'){
int a = Integer.parseInt(ms.pop().toString());
int b = Integer.parseInt(ms.pop().toString());
int n = 0;
switch(c){
case '+':n=b+a;break;
case '-':n=b-a;break;
case '*':n=b*a;break;
case '/':n=b/a;break;
}
ms.push(n);
}else{
ms.push(c);
}
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
System.out.println(ms.getSize());
try {
System.out.println(ms.pop());
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
1.*/优先级高于+-
2.表达式中相同优先级的操作符自左向右计算
3.函数输入字符串"1+(4-3)*5/5",函数返回结果为2
使用api中stack
将前缀转为后缀
/**
* 中缀表达式 转 后缀表达式
*/
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Stack;
public class ExpressConvert {
/**
* 优先级比较
* @param operator1 比较值
* @param operator2 被比较值
* @return 小于等于返回false,大于返回true
*/
public boolean comparePrior(char operator1, char operator2) {
if('(' == operator2) {
return true;
}
if ('*' == operator1 || '/' == operator1) {
if ('+' == operator2 || '-' == operator2) {
return true;
}
}
return false;
}
/**
* 转为后缀表达式:
* 1、如果是"("直接压入stack栈。
* 2、如果是")"，依次从stack栈弹出运算符加到数组newExpressionStrs的末尾，知道遇到"("；
* 3、如果是非括号，比较扫描到的运算符，和stack栈顶的运算符。如果扫描到的运算符优先级高于栈顶运算符则，把运算符压入栈。否则的话，就依次把栈中运算符弹出加到数组newExpressionStrs的末尾，直到遇到优先级低于扫描到的运算符或栈空，并且把扫描到的运算符压入栈中。就这样依次扫描，知道结束为止。如果扫描结束，栈中还有元素，则依次弹出加到数组newExpressionStrs的末尾，就得到了后缀表达式。
* @param expressionStrs
* @return
*/
public List<Character> toSuffixExpression(char[] expressionStrs) {
//新组成的表达式
List<Character> newExpressionStrs = new ArrayList<Character>();
Stack<Character> stack = new Stack<Character>();
for (int i = 0; i < expressionStrs.length; i++) {
if ('('==(expressionStrs[i])) { // 如果是左括号,则入栈
stack.push(expressionStrs[i]);
} else if ('+'==expressionStrs[i] || '-' == expressionStrs[i] || '*' == expressionStrs[i] || '/' == expressionStrs[i]) {
if (!stack.empty()) { // 取出先入栈的运算符
Character s = stack.pop();
if(comparePrior(expressionStrs[i], s)) { //如果栈值优先级小于要入栈的值,则继续压入栈
stack.push(s);
} else { //否则取出值
newExpressionStrs.add(s);
}
}
stack.push(expressionStrs[i]);
} else if (')' == expressionStrs[i]) { //如果是')',则出栈,一直到遇到'('
while (!stack.empty()) {
char s = stack.pop();
if (!('(' == s)) {
newExpressionStrs.add(s);
} else {
break;
}
}
} else {
newExpressionStrs.add(expressionStrs[i]);
}
}
while (!stack.empty()) {
char s = stack.pop();
newExpressionStrs.add(s);
}
return newExpressionStrs;
}
public static void main(String[] args) {
String expressionStr = "5+(4-5+1)-4+(6-5+3)+2";
// 分割成表达式数组
char []expressionChrs = expressionStr.toCharArray();
List<Character> newExpressionStrs = new ExpressConvert().toSuffixExpression(expressionChrs);
Iterator<Character> iter = newExpressionStrs.iterator();
while(iter.hasNext()){
System.out.print(iter.next());
}
}
}
//用栈计算后缀表达式值
原理：将后缀表达只放在list中，或者数组
循环去除后缀表达式如果取出的为数字则push到stack中，如果是运算符，则将stack中的数值pop出来，用后pop出的数（+-*/）先pop出的数，然后将结果放回stack中
直到最后一个值pop出stack，即为所求
import java.util.Iterator;
import java.util.List;
import calculator.ExpressConvert;
import dataStructure.MyStack;
public class Test4 {
public static void main(String []args){
MyStack ms = new MyStack();
String str = "1+(4-3)*5/5";
char chr[] = str.toCharArray();
ExpressConvert ec = new ExpressConvert();
List<Character> list = ec.toSuffixExpression(chr);
Iterator<Character> iter = list.iterator();
while(iter.hasNext()){
Character c = iter.next();
try {
if(c=='+' || c == '-' || c == '*' || c == '/'){
int a = Integer.parseInt(ms.pop().toString());
int b = Integer.parseInt(ms.pop().toString());
int n = 0;
switch(c){
case '+':n=b+a;break;
case '-':n=b-a;break;
case '*':n=b*a;break;
case '/':n=b/a;break;
}
ms.push(n);
}else{
ms.push(c);
}
} catch (Exception e) {
// TODO Auto-generated catch block
<
4000
/span>e.printStackTrace();
}
}
System.out.println(ms.getSize());
try {
System.out.println(ms.pop());
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
} e.printStackTrace();
}
}
}
//自定义栈 （简单的） 欢迎吐槽
import java.util.ArrayList;
import java.util.List;
import java.util.Stack;
/**
* 数据结构 栈
* 使用数组实现
* @author Administrator
*
*/
public class MyStack<T> {
private int top ;//栈顶
private Object[] obj;
private int max=10;
private int size;//栈大小
public MyStack(){
this.obj = new Object[max];
}
public boolean empty(){
if(size == 0)
return true;
return false;
}
public T pop() throws Exception{
if(size==0) throw new Exception("下表越界");
Object objct = obj[top];
obj[top--] = null;
size --;
return (T)objct;
}
public T push(Object o) throws Exception{
if(size==max) throw new Exception("下标越界");
obj[++top] = o;
size ++;
return (T)obj[top];
}
public int getSize(){
return size;
}
public static void main(String []args){
MyStack ms = new MyStack();
try {
ms.push("aaa");
ms.push("bbb");
ms.push("ccc");
System.out.println(ms.pop()+" "+ms.pop());
System.out.println(ms.size);
System.out.println(1+(4-3)*5/5);
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
//使用自定义stack，前缀转中缀
/**
* 中缀表达式 转 后缀表达式
*/
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import dataStructure.MyStack;
public class ExpressConvert {
/**
* 优先级比较
* @param operator1 比较值
* @param operator2 被比较值
* @return 小于等于返回false,大于返回true
*/
public boolean comparePrior(char operator1, char operator2) {
if('(' == operator2) {
return true;
}
if ('*' == operator1 || '/' == operator1) {
if ('+' == operator2 || '-' == operator2) {
return true;
}
}
return false;
}
/**
* 转为后缀表达式:
* 1、如果是"("直接压入stack栈。
* 2、如果是")"，依次从stack栈弹出运算符加到数组newExpressionStrs的末尾，知道遇到"("；
* 3、如果是非括号，比较扫描到的运算符，和stack栈顶的运算符。如果扫描到的运算符优先级高于栈顶运算符则，把运算符压入栈。否则的话，就依次把栈中运算符弹出加到数组newExpressionStrs的末尾，直到遇到优先级低于扫描到的运算符或栈空，并且把扫描到的运算符压入栈中。就这样依次扫描，知道结束为止。如果扫描结束，栈中还有元素，则依次弹出加到数组newExpressionStrs的末尾，就得到了后缀表达式。
* @param expressionStrs
* @return
*/
public List<Character> toSuffixExpression(char[] expressionStrs){
//新组成的表达式
List<Character> newExpressionStrs = new ArrayList<Character>();
MyStack<Character> MyStack = new MyStack<Character>();
try {
for (int i = 0; i < expressionStrs.length; i++) {
if ('('==(expressionStrs[i])) { // 如果是左括号,则入栈
MyStack.push(expressionStrs[i]);
} else if ('+'==expressionStrs[i] || '-' == expressionStrs[i] || '*' == expressionStrs[i] || '/' == expressionStrs[i]) {
if (!MyStack.empty()) { // 取出先入栈的运算符
Character s = MyStack.pop();
if(comparePrior(expressionStrs[i], s)) { //如果栈值优先级小于要入栈的值,则继续压入栈
MyStack.push(s);
} else { //否则取出值
newExpressionStrs.add(s);
}
}
MyStack.push(expressionStrs[i]);
} else if (')' == expressionStrs[i]) { //如果是')',则出栈,一直到遇到'('
while (!MyStack.empty()) {
char s = MyStack.pop();
if (!('(' == s)) {
newExpressionStrs.add(s);
} else {
break;
}
}
} else {
newExpressionStrs.add(expressionStrs[i]);
}
}
while (!MyStack.empty()) {
char s = MyStack.pop();
newExpressionStrs.add(s);
}
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return newExpressionStrs;
}
public static void main(String[] args) {
String expressionStr = "5+(4-5+1)-4+(6-5+3)+2";
// 分割成表达式数组
char []expressionChrs = expressionStr.toCharArray();
List<Character> newExpressionStrs;
try {
newExpressionStrs = new ExpressConvert().toSuffixExpression(expressionChrs);
Iterator<Character> iter = newExpressionStrs.iterator();
while(iter.hasNext()){
System.out.print(iter.next());
}
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
//计算
public class Test4 {
public static void main(String []args){
MyStack ms = new MyStack();
String str = "1+(5-3)*5/5";
char chr[] = str.toCharArray();
ExpressConvert ec = new ExpressConvert();
List<Character> list = ec.toSuffixExpression(chr);
Iterator<Character> iter = list.iterator();
while(iter.hasNext()){
Character c = iter.next();
try {
if(c=='+' || c == '-' || c == '*' || c == '/'){
int a = Integer.parseInt(ms.pop().toString());
int b = Integer.parseInt(ms.pop().toString());
int n = 0;
switch(c){
case '+':n=b+a;break;
case '-':n=b-a;break;
case '*':n=b*a;break;
case '/':n=b/a;break;
}
ms.push(n);
}else{
ms.push(c);
}
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
System.out.println(ms.getSize());
try {
System.out.println(ms.pop());
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理 
相关文章推荐
- 去哪儿笔试解决方案二(java)
- 去哪儿笔试解决方案二(java)
- 去哪儿2015笔试题JAVA实现
- 去哪儿笔试：部分和问题 java
- 去哪儿笔试解决方案
- java按值传参与按引用传参_旺旺老师Java学习解决方案_第一季
- 应聘Java笔试时可能出现问题及其答案
- JNI DETECTED ERROR IN APPLICATION: can't call void XXX on instance of java.lang.Class <XXX>解决方案
- java中文乱码解决方案和经验-Java基础-Java-编程开发
- JavaEE应用中MySQL中文乱码完全解决方案----转自：http://www.blogjava.net/bolo
- 关于java文件下载文件名乱码问题解决方案
- 调用远程主机上的RMI服务时抛出java.rmi.ConnectException: Connection refused to host: 127.0.0.1异常原因及解决方案
- 精选30道Java笔试题解答
- （十六）java并发编程--线程的死锁解决方案(生产者和消费者几种实现方式)
- 图片缩放时java.lang.IllegalArgumentException: pointerIndex out of range解决方案
- Access java jdbc连接 insert插入的数据 中文乱码解决方案!!!
- 00001笔试题（JAVA）
- struts项目中文乱码解决方案（java中文乱码解决方案）
- 运行mvn命令出现java/lang/NoClassDefFoundError: java/lang/Object错误解决方案及原因分析
- java中文乱码完全解决方案