解一元一次方程伪代码:
class TreeStructure
expression:string ->表达式
left:TreeStructure ->左边的树结构
right:TreeStructure ->右边的树结构
state=0:string ->访问状态
parent:TreeStructure ->指向于父节点
operator:string ->操作符
result:int ->结果
def 栈对字符串根据符号进行分割构造成树(传入一个字符变量str)
声明一个名为root的树,将str填入其构造方法
声明一个栈并将root树压入栈中
while 栈不为空
声明一个名为current的变量并将栈中第一个赋值给它
调用方法查找current的expression中符号所在位置获取返回值并命名为num
IF num为-1
IF 将第一个“(”与最后一个“)”将其消除掉
current出栈
创建一个变量命名为left,并将其出去括号的字符串填入构造方法
将当前出栈的current赋值给left的parent
将left赋值给root树的左树
将left压入栈中
ELSE
current出栈
将当前current对应的expression赋值给它的result属性
ELSE IF num大于0
current出栈
根据下标0到返回值,来截取字符串,得到符号左边的字符串 = leftStr
根据返回值+1到字符串长度,来截取字符串,得到符号右边的字符串 = rightStr
left = new TreeStucture(leftStr)
right = new TreeStucture(rightStr)
将当前num对应的符号赋值给current的operator
将current加入到left.parent作为父节点,并赋值给root的左树
将current加入到right.parent作为父节点,并赋值给root的右树
将right树压入栈中
将left树压入栈中
def 根据树后序遍历出来的结果计算表达式(传入已经构建好的字符串树变量root)
声明一个stack栈并将root压入栈中
while stack栈不为空
current 获取栈顶的树并赋值作为当前的树
IF current的state等于他子节点个数时
IF current.opteator不为空时
对current的opteator运算符进行判断后将current的左右子节点的result进行运算
ELSE IF current只有一个子节点
将current的子节点的result赋值给current的result
将current出栈
IF 将当前current的parent不为空
父节点中state+=1
ELSE
IF 左树不为空
将左树压入stack栈中
IF 右树不为空
将右树压入stack栈中
print(root.result)
def 查找当前字符中的符号所在位置(传入一个字符串)
FOR 对字符串长度进行循环
得到当前下标的单个字符
IF 字符等于"("
计数+1
ELSE IF 字符等于")"
计数-1
ELSE IF 字符=="+" 与 计数==0
返回当前下标
FOR 以字符串最后一个字符开始进行循环
得到当前下标的单个字符
IF 字符等于"("
计数+1
ELSE IF 字符等于")"
计数-1
ELSE IF 字符等于"-" 与 计数==0
返回当前下标
FOR 对字符串长度进行循环
得到当前下标的单个字符
IF 字符等于"("
计数+1
ELSE IF 字符等于")"
计数-1
ELSE IF (字符等于"*" 或 字符等于"/") 与 计数==0
返回当前下标
返回-1
Python实现代码:
class Stack(object):
def __init__(self):
self.items = []
def is_empty(self):
return self.items == []
def peek(self):
return self.items[len(self.items) - 1]
def size(self):
return len(self.items)
def push(self, item):
self.items.append(item)
def pop(self):
return self.items.pop()
class TreeNode(object):
def __init__(self, x):
self.expression = x
self.left = None
self.right = None
self.parent = None
self.state = 0
self.operator = None
self.result= None
def structuralTree(str):
root = TreeNode(str)
stack = Stack()
stack.push(root)
while stack.size() >0 :
current = stack.peek()
nums = strToTree(current.expression)
if nums == -1 :
if current.expression.startswith("(") and current.expression.endswith(")") :
current=stack.pop()
expression = current.expression[1:len(current.expression)-1];
left = TreeNode(expression)
left.parent = current
current.left = left
stack.push(left)
else:
current=stack.pop()
current.result=current.expression
elif nums > 0 :
current=stack.pop()
leftStr = current.expression[0:nums]
rightStr = current.expression[nums+1:len(str)]
operator = current.expression[nums:nums+1]
current.operator = operator
leftTree = TreeNode(leftStr)
rightTree = TreeNode(rightStr)
leftTree.parent = current
rightTree.parent = current
current.left = leftTree
current.right = rightTree
stack.push(rightTree)
stack.push(leftTree)
return root
def strToTree(str):
num = 0
for i in range(len(str)):
if str[i] == "(":
num += 1
elif str[i] == ")":
num -= 1
elif str[i] == "+" and num == 0 :
return i
for i in range(len(str[::-1])):
if str[i] == "(":
num += 1
elif str[i] == ")":
num -= 1
elif str[i] == "-" and num==0 :
return i
for i in range(len(str)):
if str[i] == "(":
num += 1
elif str[i] == ")":
num -= 1
elif (str[i] == "*" or str[i] == "/") and num==0 :
return i
return -1
def postOrder(root):
stack = Stack()
stack.push(root)
while stack.size() >0 :
current = stack.peek()
num = 0
if current.left != None:
num += 1
if current.right != None:
num += 1
if current.state == num :
if current.operator != None :
if current.operator == "+":
current.result = int(current.left.result) + int(current.right.result)
elif current.operator == "-":
current.result = int(current.left.result) - int(current.right.result)
elif current.operator == "*":
current.result = int(current.left.result) * int(current.right.result)
elif current.operator == "/":
current.result = int(current.left.result) / int(current.right.result)
elif current.left != None and current.right == None:
current.result=current.left.result
stack.pop()
if current.parent != None :
current.parent.state += 1
else:
if current.left != None:
stack.push(current.left)
if current.right != None:
stack.push(current.right)
print(root.expression,"=",root.result)
root = structuralTree("((2+3)/5-(2+3)*4-(3-3))")
postOrder(root)