java堆栈下溢[关闭]
im执行此任务，并不断在线程“main”java.lang.RuntimeException中获得异常：Stack.pop(postfix.java:74)、postfix.eval(postfix.java:221)和postfix.main（postfix.java:112)处的堆栈下溢
我不知道为什么我看着堆栈并且写得正确，我不明白为什么它在(3*4)/5时弹出的问题
import java.io.IOException;
class CharStack
{
private final int STACKSIZE= 80;
private int top;
private char[] items;
public CharStack(){
items = new char[STACKSIZE];
top =-1;
}
public boolean empty() {
if(top==-1){
return true;
}
return false;
}
public char pop() {
if(empty()){
throw new RuntimeException("Stack Underflow");
}
return items[top--];
}
public void push(char symb)
{
if(top == STACKSIZE -1) {
throw new RuntimeException("Stack Overflow");
}
items[++top] =symb;
}
public char peek() {
if(empty()){
throw new RuntimeException("Stack Underflow");
}
return items[top];
}
}
class Stack {
private final int STACKSIZE= 80;
private int top;
private double[] items;
public Stack(){
items = new double[STACKSIZE];
top =-1;
}
public void push(double x)
{
if(top == STACKSIZE -1) {
throw new RuntimeException("Stack Overflow");
}
items[++top] =x;
}
public double pop(){
if(empty()){
System.out.print(top);
throw new RuntimeException("Stack Underflow");
}
return items[top--];
}
public double peek() {
if(empty()){
throw new RuntimeException("Stack Underflow");
}
return items[top];
}
boolean empty()
{
if(top==-1){
return true;
}
return false;
}
}
public class Postfix {
public final static int MAXCOLS = 80;
public static void main(String[] args) throws IOException {
String infix, pfix;
System.out.println("Enter a infix String: ");
infix = readString().trim();
System.out.println("The original infix expr is: " + infix);
pfix = postfix(infix);
System.out.println("The Postfix expr is: " + pfix);
System.out.println("The value is : " + eval(pfix));
} // end main
public static boolean isOperand(char x)
{
if(x == '+')
{
return false;
}
else if(x == '-')
{
return false;
}
else if (x == '*')
{
return false;
}
else if (x == '/')
{
return false;
}
else if ( x== '$')
{
return false;
}
return true;
}
public static int operPrecedence(char oper)
{
if(oper == '+'||oper == '-' )
{
return 1;
}
else if (oper == '*' || oper == '/')
{
return 2;
}
else if (oper == '$')
{
return 3;
}
return 0;
}
public static boolean precedence(char top, char symb)
{
if ((top != '('||top != ')')&&symb == '(')
{
return false;
}
if (top == '(' && (symb != '('||symb != ')') )
{
return false;
}
else if((top != '('||top != ')')&&symb ==')' )
{
return true;
}
int opcode1, opcode2;
opcode1 =operPrecedence(top) ;
opcode2 =operPrecedence(symb) ;
if(opcode1>=opcode2){
return true;
}
return false;
}
public static String readString() throws IOException {
char[] charArray = new char[80];
int position = 0;
char c;
while ((c = (char) System.in.read()) != '\n') {
charArray[position++] = c;
}
return String.copyValueOf(charArray, 0, position); // turns a character array into a string, starting between zero and position-1
}// end read string
public static double eval(String infix) {
char c;
int position;
double opnd1, opnd2, value;
Stack opndstk = new Stack();
for (position = 0; position < infix.length(); position++) {
c = infix.charAt(position);
if (Character.isDigit(c)) // operand-convert the character represent of
// the digit into double and push it into the
// stack
{
opndstk.push((double) Character.digit(c, 10));
} else {
// operator
opnd2 = opndstk.pop();
opnd1 = opndstk.pop();
value = oper(c, opnd1, opnd2);
opndstk.push(value);
} // else
} // end for
return opndstk.pop();
}// end eval
public static String postfix(String infix) {
int position, outpos = 0;
char symb;
char[] postr = new char[MAXCOLS];
CharStack opstk = new CharStack();
for (position = 0; position < infix.length(); position++) {
symb = infix.charAt(position);
if (isOperand(symb)) {
postr[outpos++] = symb;
} else {
while (!opstk.empty() && precedence(opstk.peek(), symb)) {
postr[outpos++] = opstk.pop();
} // end while
if (symb != ')') {
opstk.push(symb);
} else {
opstk.pop();
}
} // end else
} // end for
while (!opstk.empty()) {
postr[outpos++] = opstk.pop();
}
return String.copyValueOf(postr, 0, outpos);
}// end pos
public static double oper(char symb, double op1, double op2) {
double value = 0;
switch (symb) {
case '+':
value = op1 + op2;
break;
case '-':
value = op1 - op2;
break;
case '*':
value = op1 * op2;
break;
case '/':
value = op1 / op2;
break;
case '$':
value = Math.pow(op1, op2);
break;
default:
throw new RuntimeException("illegal operator: " + symb);
}// end switch
return value;
}// end oper
}
共有1个答案
您遇到的问题至少有一部分是isoperand方法。字符(和)不是操作数，但是，当将它们传递给此方法时，它将返回true。为了快速测试，我在方法的末尾添加了以下行：
else if (x == '(')
{
return true;
}
else if (x == ')')
{
return true;
}
和示例输入,(3*4)/5)成功运行。但是,这会中断后缀输出,因为它将括号排除在后缀版本之外,而是打印34*5/,我猜您不想这样做。
然后，根据收到的错误消息，我查看了eval方法，这是问题的来源：
Exception in thread "main" java.lang.RuntimeException: Stack Underflow
at Stack.pop(Postfix.java:74)
at Postfix.eval(Postfix.java:221)
at Postfix.main(Postfix.java:112)
注意行postfix.java:221，它指示调用创建错误的方法的行。如果您在调用该行之前输出字符C，您会注意到C是(字符，这意味着您的eval方法将(识别为运算符，并试图在其后面弹出两个操作数，从而导致下溢。
通过一些system.out.println()调用并查看您的错误来确定所有这些都相当简单。我将把实际的修理工作留给你，但至少你现在有了一个前进的方向。
-
（使用Java 15.0+) 我正在用这些实现一个堆栈 如何检查堆栈是否下溢？从Overflow boolean变量中，我们知道如果一个数字不能用8位来表示，就会导致溢出。但是，如果数字不能以这种方式表示，我们如何检查呢？我还认为应该有更多的情况下堆栈溢出，像jumpz或jumpn导致通过指令的无限循环。
-
我有一个执行快速排序的应用程序。在我开始给它一些更大的数字（我第一次得到它是10000000）之前，它工作得很好。我知道是由递归引起的，但我不明白为什么我的应用程序会因此而崩溃。如有任何建议，将不胜感激。这是我的密码：
-
我正在使用一个正则表达式从任意长的输入字符串中提取键值对，并且遇到了这样的情况：对于具有重复模式的长字符串，它会导致堆栈溢出。 KV解析代码如下所示： 一些虚构的输出示例： 我显式地将generic放在上面，而不是在解析之前检查最大字符串长度的hacks（例如）。 我能想出的最粗俗的解决方法，一个真正的反模式，是 有趣的是，它在我试过的几次运行中都起作用了，但它不是一个值得推荐的有品位的东西。：-
-
问题内容： 下面给出的代码显示了运行时的Stackoverflow错误。但是，如果我使另一个类CarChange创建Car的对象，它将成功运行。我是一个初学者，请执行以下代码以了解在Java中进行向上转换的重要性。 问题答案： 一个stackoverflow通常意味着您有一个无限循环。 收到此消息的原因是因为您从testdrive方法调用驱动器，并且在该方法中再次调用drive。
-
问题内容： 这有效：http : //play.golang.org/p/-Kv3xAguDR。 这导致堆栈溢出：http : //play.golang.org/p/1-AsHFj51O。 我不明白为什么。在这种情况下，使用接口的正确方法是什么？ 问题答案： 这个 将呼叫您的，依次呼叫，等等。如果您需要解组JSON然后对其进行处理，那么一种巧妙的技术是声明一个本地类型，将数据解组到其中，然后转换
-
我写了以下内容： 解决4clojure.com的问题#118:http://www.4clojure.com/problem/118 当我询问时，不出所料，我会得到一个clojure.lang.lazyseq，但我不知道这与简单地删除lazy-seq“包装”有什么区别。 当然，现在如果删除lazy-seq，我会得到一个stackoverflow，为什么要执行这个： 否则（也就是说：如果我让lazy