【数据结构连载一栈】【四则运算--后缀表达式】javascript

function Node(value) {
    this.data = value;
    this.next = null;
}

function LinkedStack() {
    this.head = null;
    this._length = 0;

    this.clear = function () {
        this.head = null;
        this._length = 0;
    };
    this.empty = function () {
        return this.head === null;
    };
    this.get = function () {
        if (this.empty()) {
            throw new Error("栈为空");
        }
        return this.head.data;
    };
    this.push = function (value) {
        const new_node = new Node(value);
        if (!this.empty()) {
            new_node.next = this.head;
        }
        this.head = new_node;
        this._length++;
    };
    this.pop = function () {
        if (this.empty()) {
            throw new Error("栈为空");
        }
        const data = this.head.data;
        this.head = this.head.next;
        this._length--;
        return data;
    };
    this.length = function () {
        return this._length;
    };
}

const EXPS = ["+", "-", "*", "/", "(", ")"]

// 中缀表达式转后缀表达式
function inv_pol_suf_exp(expression) {
    let stack = new LinkedStack();
    let expressions = expression.split(" ");
    let result = [];
    for (let i = 0; i < expressions.length; i++) {
        const cur = expressions[i];
        if (EXPS.indexOf(cur) === -1) {
            result.push(parseFloat(cur));
        } else {
            result.push.apply(result, priority_exp(cur, stack))
        }
    }
    while (!stack.empty()) {
        result.push(stack.pop());
    }
    return result.join(" ");

}

// 遇到符号类别处理栈数据
function priority_exp(exp, stack) {
    let l = [];
    if (exp === ")") {
        while (!stack.empty()) {
            const s = stack.pop();
            if (s === "(") {
                return l;
            }
            l.push(s);
        }
    } else if (exp === "-" || exp === "+") {
        while (!stack.empty()) {
            if (stack.get() === "(") {
                break
            }
            l.push(stack.pop());
        }
    } else if (exp === "*" || exp === "/") {
        while (!stack.empty()) {
            if (stack.get() === "*" || stack.get() === "/") {
                l.push(stack.pop());
            } else {
                break;
            }
        }
    }
    stack.push(exp);
    return l;
}

// 计算后缀表达式
function arithmetic(exp) {
    let stack = new LinkedStack();
    let exps = exp.split(" ");
    for (let i = 0; i < exps.length; i++) {
        if (EXPS.indexOf(exps[i]) === -1) {
            stack.push(exps[i]);
        } else {
            num1 = stack.pop();
            num2 = stack.pop();
            stack.push(eval(num2 + exps[i] + num1));
        }
    }
    return stack.pop();
}

// 9 3 1 - 3 * + 10 2 / * 后缀表达式
res = inv_pol_suf_exp("9 + ( 3 - 1 ) * 3 + 10 / 2");
ret = arithmetic(res);
console.log(ret)