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

class Node(object):
    def __init__(self, data=None):
        self.data = data
        self.next = None

    def __str__(self):
        return "数据：{data}，地址：{next}".format(data=self.data, next=id(self.next))


class LinkedStack(object):
    def __init__(self):
        self._length = 0
        self._head = None

    def __str__(self):
        s = ""
        cur = self._head
        while cur:
            s += str(cur.data)
            cur = cur.next
        return s

    def clear(self):
        self._head = None
        self._length = 0

    def empty(self):
        return self._head is None

    def get(self):
        if self.empty():
            raise Exception("栈为空")
        return self._head.data

    def push(self, data):
        new_node = Node(data)
        if not self.empty():
            new_node.next = self._head
        self._head = new_node
        self._length += 1

    def pop(self):
        if self.empty():
            raise Exception("栈为空")
        data = self._head.data
        self._head = self._head.next
        self._length -= 1
        return data

    def length(self):
        return self._length


def priority_exp(i, stack):
    l = []
    if i == ")":
        while not stack.empty():
            s = stack.pop()
            if s == "(":
                return l
            l.append(s)
    elif i in ["-", "+"]:
        while not stack.empty():
            if stack.get() in ["*", "/", "+", "-"]:
                s = stack.pop()
                l.append(s)
            else:
                break
    elif i in ["*", "/"]:
        while not stack.empty():
            if stack.get() in ["*", "/"]:
                s = stack.pop()
                l.append(s)
            else:
                break
    stack.push(i)
    return l


# 中缀表达式转后缀表达式
def inv_pol_suf_exp(expression):
    # 初始化栈
    stack = LinkedStack()
    res = []
    for i in expression.split():
        if i not in ["+", "-", "(", "*", "/", ")"]:  # 数字直接输出
            res.append(i)
        else:  # 是符号的话需要判断栈内的符号优先级，将高于等于当前优先级的符号输出，然后当前符号进栈
            res.extend(priority_exp(i, stack))
    while not stack.empty():
        res.append(stack.pop())
    return " ".join(res)


# 四则运算
def calculate(b, a, operator):
    ret = {}
    exec('ret["result"]={b}{operator}{a}'.format(b=b, operator=operator, a=a))
    return float(ret['result'])


def arithmetic(expression):
    stack = LinkedStack()
    for i in expression.split():
        if i not in ['+', "-", "*", "/"]:
            stack.push(float(i))
        else:
            a = stack.pop()
            b = stack.pop()
            stack.push(calculate(b, a, i))
    return stack.pop()


if __name__ == '__main__':
    # 9 3 1 - 3 * + 10 2 / * 后缀表达式
    res = inv_pol_suf_exp("9 + ( 3 - 1 )  * 3 + 10 / 2")
    print(arithmetic(res))