PYTHON实现算术表达式构造二叉树

LEETCOCE 224. Basic Calculator

Implement a basic calculator to evaluate a simple expression string.

The expression string may contain open ( and closing parentheses ), the plus + or minus sign -, non-negative integers and empty spaces .

意思是实现只有加减法的带空格的算术表达式。

1.用构造二叉树的方法

对于一个算式,找到最后一个被使用的运算符作为划分,以此运算符为界,递归计算左边的值,递归计算右边的值,然后以此运算符进行运算,即可得到结果.最后一个被使用的运算符是什么呢? 例如： 2+3*(4-1)-5/1 肯定先算括号里的, 然后算* / 法,最后才考虑+,-法 . 所以,先考虑+,-法,再考虑* / 法. 括号外的+-*/可能很多，所以确定一个原则,找整个算式中最右边+-,*/. 由于要找的是括号外的+-*/, 所以得想办法避免记录括号内的+-*/,所以设置了一个标志p,初始0 一旦遇到一个左括号, p+1, 这时候说明目前在括号内，不应该记录+-*/， 当遇到右括号，p-1,p恢复为0，这时候说明目前已经走出括号，可以记录+-*/ . 扫描完真个算时候,C1记录了最右边的括号外的+-号，C2记录了最右边的括号外的*/号. 如果c1<0,说明没扫描到括号外的+-号, 那么只能考虑*/号作为最后一个运算的运算符了. 把c1=c2,然后判断c1<0, 如果还<0, 说明括号外也没有*/号， 说明整个算式被括号包围起来了. 所以可以递归运算时忽略这对括号，即递归(x+1,y-1)的算式, 返回它的子树根.代码如下:

class Treenode:
    def __init__(self,x):
        self.val=x
        self.left=self.right=None
        
def calculate(s):
        """
        :type s: str
        :rtype: int
        """
        def buildTree(s):
            n=len(s)
            if n==1:return Treenode(s[0])
            k,p=-1,0
            for i in range(n):
                c=s[i]
                if c=='(':
                    p+=1
                elif c==')':
                    p-=1
                elif c in ('+','-'):
                    if p==0:k=i
            if k<0:return buildTree(s[1:-1])        
            root=Treenode(s[k])
            root.left=buildTree(s[:k])
            root.right=buildTree(s[k+1:])
            return root
        
        def f(root):
            if root.left==None:return int(root.val)
            l=f(root.left)
            r=f(root.right)
            if root.val=='+':return l+r
            return l-r
        
        t,i=[],0
        while i<len(s):
            c=s[i]
            if c in '()+-':
                t.append(c)
                i+=1
            elif c==' ':
                i+=1
            else:
                k=i
                while i<len(s) and s[i] in '0123456789':i+=1
                t.append(s[k:i])
        #print(t)
        root=buildTree(t)
        
        return f(root)

上述算法可以做个优化,不用真的构造二叉树再遍历,二个过程合二为一.代码如下:

def calculate(s):
        """
        :type s: str
        :rtype: int
        """
        def dp(s):
            n=len(s)
            if n==1:return int(s[0])
            p=0
            for i in range(n-1,-1,-1):
                c=s[i]
                if c=='(':
                    p+=1
                elif c==')':
                    p-=1
                elif c in ('+','-'):
                    if p==0:break
            else:return dp(s[1:-1])        
            l=dp(s[:i])
            r=dp(s[i+1:])
            if s[i]=='+':return l+r
            return l-r
        
        t,i=[],0
        while i<len(s):
            c=s[i]
            if c in '()+-':
                t.append(c)
                i+=1
            elif c==' ':
                i+=1
            else:
                k=i
                while i<len(s) and s[i] in '0123456789':i+=1
                t.append(s[k:i])
        #print(t)
        return dp(t)

2.逆波兰表达式

逆波兰表达式又称后缀表达式，运算符位于操作数之后.比如(3+4)×5-6的逆波兰表达式是“3 4 + 5 × 6 -”.生成逆波兰表达式的算法如下:从左至右扫描表达式，遇到数字时，将数字压入堆栈，遇到运算符时，弹出栈顶的两个数，用运算符对它们做相应的计算（次顶元素 op 栈顶元素），并将结果入栈；重复上述过程直到表达式最右端，最后运算得出的值即为表达式的结果.具体点:

1. 初始化两个栈：运算符栈s1和储存中间结果的栈s2；
2. 从左至右扫描中缀表达式；
3. 遇到操作数时，将其压s2；
4. 遇到运算符时，比较其与s1栈顶运算符的优先级：
   1. 如果s1为空，或栈顶运算符为左括号“(”，则直接将此运算符入栈；
   2. 否则，若优先级比栈顶运算符的高，也将运算符压入s1；
   3. 否则，将s1栈顶的运算符弹出并压入到s2中，再次转到(4-1)与s1中新的栈顶运算符相比较；
5. 遇到括号时：
   1. 如果是左括号“(”，则直接压入s1；
   2. 如果是右括号“)”，则依次弹出s1栈顶的运算符，并压入s2，直到遇到左括号为止，此时将这一对括号丢弃；
6. 重复步骤2至5，直到表达式的最右边；
7. 将s1中剩余的运算符依次弹出并压入s2；
8. 依次弹出s2中的元素并输出，结果即为后缀表达式

def calculate(s):
        """
        :type s: str
        :rtype: int
        """

s1,s2,n,i=[],[],len(s),0
        while i<n:
            c=s[i]
            if c in '+-':
                while s1 and s1[-1]!='(':s2.append(s1.pop())
                s1.append(c)
                i+=1
            elif c=='(':
                s1.append(c)
                i+=1
            elif c==')':
               op=s1.pop()
               while op!='(':
                  s2.append(op)
                  op=s1.pop()
               i+=1
            elif c==' ':
                i+=1
            else:
                k=i
                while i<len(s) and s[i] in '0123456789':i+=1
                s2.append(s[k:i])
        while s1:s2.append(s1.pop())

stack=[]
        for c in s2:
            if c in '+-':
               r,l=stack.pop(),stack.pop()
               if c=='+':
                  stack.append(l+r)
               else:
                  stack.append(l-r)
            else:
               stack.append(int(c))
        return stack[-1]

3.其他方法

def calculate(s):
        """
        :type s: str
        :rtype: int
        """
        sign,val,curr,stack = 1,0,0,[]
     for c in s:
            if c in '0123456789':
                curr = curr * 10 + int(c)
            elif c in '+-':
                val += sign * curr
                curr,sign = 0,int(c+'1')
            elif c == '(':
                stack.append(val)
                stack.append(sign)
                sign,val = 1,0
            elif c == ')':
                val += sign * curr
                curr = 0
                val *= stack.pop()
                val += stack.pop()
     if curr: val += curr * sign
     return val