JavaScript栈实现中缀转后缀表达式求值返回NaN问题求助

核心问题1：Stack类的pop方法无返回值 #

你的pop函数仅修改了栈顶指针，没有返回被弹出的元素，导致所有pop()调用都返回undefined，这是输出undefined的直接原因。

修复后的pop函数：

function pop(){
    return this.dataStore[--this.top];
}

核心问题2：中缀转后缀的逻辑缺陷 #

原代码仅适配单运算符场景，且操作数顺序、后缀构造逻辑错误，求值时也未考虑运算符的顺序依赖（比如除法、减法）。

完整修复代码 #

function Stack(){
    this.dataStore=[];
    this.top = 0;
    this.push = push;
    this.pop = pop;
    this.peek = peek;
    this.length = length;
    this.clear = clear;
}
function push(element){
    this.dataStore[this.top++] = element;
}
// 修复pop方法，添加返回值
function pop(){
    return this.dataStore[--this.top];
}
function peek(){
    return this.dataStore[this.top-1];
}
function length(){
    return this.top;
}
function clear(){
    this.top = 0;
}

// 运算符优先级判断，用于中缀转后缀的规则处理
function getPriority(op) {
    switch(op) {
        case '+':
        case '-':
            return 1;
        case '*':
        case '/':
            return 2;
        default:
            return 0;
    }
}

function convertInfixToPostfix(input) {
    var operands = new Stack();
    var operators = new Stack();
    var numStr = "";
    var postfix = [];

    for (var i = 0; i < input.length; i++) {
        var curr = input[i];
        // 收集多位数或小数
        if (!isNaN(curr) || curr === '.') {
            numStr += curr;
        } else if (curr === '+' || curr === '-' || curr === '*' || curr === '/') {
            // 把之前收集的数字存入操作数栈和后缀数组
            if (numStr !== "") {
                operands.push(numStr);
                postfix.push(numStr);
                numStr = "";
            }
            // 处理运算符优先级：栈顶运算符优先级更高时，先弹出到后缀表达式
            while (operators.length() > 0 && getPriority(operators.peek()) >= getPriority(curr)) {
                postfix.push(operators.pop());
            }
            operators.push(curr);
        }
    }
    // 处理最后一个未入栈的数字
    if (numStr !== "") {
        operands.push(numStr);
        postfix.push(numStr);
    }
    // 弹出栈中剩余的所有运算符
    while (operators.length() > 0) {
        postfix.push(operators.pop());
    }

    var postfixStr = postfix.join(' ');
    console.log("Postfix expression: " + postfixStr);

    // 后缀表达式求值逻辑
    var evalStack = new Stack();
    for (var item of postfix) {
        if (!isNaN(item)) {
            evalStack.push(parseFloat(item));
        } else {
            // 注意顺序：后缀表达式是op1 op2 operator，所以先弹op2再弹op1
            var op2 = evalStack.pop();
            var op1 = evalStack.pop();
            let result;
            switch(item) {
                case '+':
                    result = op1 + op2;
                    break;
                case '-':
                    result = op1 - op2;
                    break;
                case '*':
                    result = op1 * op2;
                    break;
                case '/':
                    result = op1 / op2;
                    break;
            }
            evalStack.push(result);
        }
    }
    var finalResult = evalStack.pop();
    console.log("Postfix evaluated: " + finalResult);
    return finalResult;
}

// 测试用例
convertInfixToPostfix("100/5"); // 输出Postfix expression: 100 5 /，求值结果20
convertInfixToPostfix("10+2*3"); // 输出Postfix expression: 10 2 3 * +，求值结果16

修复说明 #

• 补全pop方法的返回值，解决undefined问题。
• 新增运算符优先级处理，支持多运算符的复杂表达式转换。
• 后缀求值时严格遵循op1 op2 operator的规则，避免除法、减法的顺序错误。
• 支持多位数和小数，适配更通用的表达式场景。

内容的提问来源于stack exchange，提问作者John Mark Entrina