def product_rule(currentNode, currentValue, dStack):
currentNode.Key = '/'
gTree = currentNode.getLeftChild()
dgTree = BinaryTree(currentNode.getLeftChild().key)
dgNode = dgTree
iStack = Stack()
build_tree(currentNode.getLeftChild(), dStack, dgNode, iStack)
dgTree = derivative(dgTree)
fTree = currentNode.getRIghtChild()
dfTree = BinaryTree(currentNode.getRightChild().key)
dfNode = dfTree
iStack = Stack()
build_tree(currentNode.getRightChild(), dStack, dgNode, iStack)
dfTree = derivative(dfTree)
prodTree = BinaryTree('+')
prodNode = quoTree
prodNode = prodNode.getLeftChild
prodNode.insertLeft('*')
prodNode.insertRight('*')
prodNode = quoNode.getRightChild
prodNode.insertRight(dgTree)
prodNode.insertLeft(fTree)
prodNode = dStack.pop()
prodNode.getLeftChild()
prodNode.insertRight(dfTree)
prodNode.insertLeft(gTree)
der_output(prodNode)
def chain_rule(currentNode, currentValue, dStack):
currentNode.key = "*"
power = currentNode.getRightChild().key
innerTree = currentNode.getLeftChild()
derInnerTree = BinaryTree(innerTree.key)
derInnerNode = derInnerTree
iStack = Stack()
Misc.build_tree(currentNode.getLeftChild(), dStack, derInnerNode, iStack)
derivative(derInnerTree)
# building tree based on chain rule that will be inserted into original tree
chainTree = BinaryTree('*')
chainNode = chainTree
chainNode.insertRight(derInnerTree)
chainNode.insertLeft('*')
chainNode = chainNode.getLeftChild()
chainNode.insertLeft(power)
chainNode.insertRight('^')
chainNode = chainNode.getRightChild()
chainNode.insertRight(power - 1)
chainNode.insertLeft(innerTree)
# inserting chain tree's first kids into original tree
currentNode.insertLeft(chainTree.getLeftChild())
currentNode.insertRight(chainTree.getRightChild())
def buildParseTree(fpexp):
fplist = mystr = re.findall(r'\s*([()+*/-]|\d+)', fpexp)
pStack = Stack()
eTree = BinaryTree('')
pStack.push(eTree)
currentTree = eTree
for i in fplist:
if i == '(':
currentTree.insertLeft('')
pStack.push(currentTree)
currentTree = currentTree.getLeftChild()
elif i in ['+', '-', '*', '/']:
currentTree.setRootVal(i)
currentTree.insertRight('')
pStack.push(currentTree)
currentTree = currentTree.getRightChild()
elif i == ')':
currentTree = pStack.pop()
elif i not in ['+', '-', '*', '/', ')']:
try:
currentTree.setRootVal(int(i))
parent = pStack.pop()
currentTree = parent
except ValueError:
raise ValueError("token '{}' is not a valid integer".format(i))
return eTree
def buildParseTree(fpexp):
fplist = split_expression(fpexp) # Exercise question
pStack = Stack()
eTree = BinaryTree('')
pStack.push(eTree)
currentTree = eTree
for i in fplist:
if i == '(':
currentTree.insertLeft('')
pStack.push(currentTree)
currentTree = currentTree.getLeftChild()
elif i in ['+', '-', '*', '/']:
currentTree.setRootVal(i)
currentTree.insertRight('')
pStack.push(currentTree)
currentTree = currentTree.getRightChild()
elif i == ')':
currentTree = pStack.pop()
elif i not in ['+', '-', '*', '/', ')']:
try:
currentTree.setRootVal(int(i))
parent = pStack.pop()
currentTree = parent
except ValueError:
raise ValueError("token '{}' is not a valid integer".format(i))
return eTree
def buildParseTree(math_exp):
lst = math_exp.split()
pstack = Stack()
etree = BinaryTree("")
pstack.push(etree)
currentTree = etree
for i in lst:
if i == "(":
currentTree = currentTree.insertLeft("") # 此时尚在根结点（父节点）
pstack.push(currentTree)
currentTree = currentTree.getLeftChild()
elif i not in "+-*/)":
currentTree.setRootVal(eval(i))
parent = pstack.pop()
currentTree = parent
elif i in "+-*/":
currentTree.setRootVal(i)
currentTree.insertRight("")
pstack.push(currentTree)
elif i == ")":
currentTree = pstack.pop()
else:
raise ValueError("Unknow Operator:{}".format(i))
return currentTree
def build_parse_tree(exp_string):
exp_list = exp_string.split() # 表达式符号列表
parent_stack = Stack() # 存储父节点的栈
parse_tree = BinaryTree() # 解析树
node = parse_tree # 当前节点
for char in exp_list:
if char == '(':
# 创建并切换到左子节点
parent_stack.push(node)
node.insert_left()
node = node.left_child
elif char in '+-*/':
# 切换回父节点，设置父节点的值
node = parent_stack.pop()
node.data = char
# 创建并切换到右子节点
parent_stack.push(node)
node.insert_right()
node = node.right_child
elif char in ')':
# 切换回父节点
node = parent_stack.pop()
elif char.isdigit():
# 设置当前节点的值
node.data = eval(char)
else:
raise ValueError(f'Unknown character: {char}')
return parse_tree
def buildParseTree(fpexp):
fplist = fpexp.split()
pStack = Stack() # following parent node
eTree = BinaryTree('')
pStack.push(eTree)
currentTree = eTree
for i in fplist:
if i == '(':
currentTree.insertLeft('')
pStack.push(currentTree)
currentTree = currentTree.getLeftChild()
elif i in ['+', '-', '*', '/']:
currentTree.setRootVal(i)
currentTree.insertRight('')
pStack.push(currentTree)
currentTree = currentTree.getRightChild()
elif i == ')':
currentTree = pStack.pop()
elif i not in ['+', '-', '*', '/', ')']: # operands
try:
currentTree.setRootVal(int(i))
parent = pStack.pop()
currentTree = parent
except ValueError:
raise ValueError(
"Token '{}' is not a valid integer.".format(i))
return eTree
def buildParseTree(expr):
lot = expr.split()
tree = BinaryTree("")
posStack = Stack()
posStack.push(tree)
currentTree = tree
for token in lot:
if token == "(":
currentTree.insertLeft("")
posStack.push(currentTree)
currentTree = currentTree.getLeftChild()
elif token == ")":
currentTree = posStack.pop()
elif token in ["and", "or"]:
currentTree.setRootVal(token)
currentTree.insertRight("")
posStack.push(currentTree)
currentTree = currentTree.getRightChild()
elif token == "not":
parent = posStack.pop()
currentTree = parent
currentTree.setRootVal(token)
posStack.push(currentTree)
currentTree = currentTree.getLeftChild()
elif token in ["1", "0"]:
currentTree.setRootVal(int(token))
parent = posStack.pop()
currentTree = parent
return tree
def buildParseTree(fpexp):
fplist = fpexp.split()
pStack = Stack()
eTree = BinaryTree('')
pStack.push(eTree)
currentTree = eTree
for word in fplist:
if word == '(':
currentTree.insertLeft('')
pStack.push(currentTree)
currentTree = currentTree.getLeftChild()
elif word not in '+-*/)':
currentTree.setRootVal(eval(word))
currentTree = pStack.pop()
elif word in '+-*/':
currentTree.setRootVal(word)
currentTree.insertRight('')
pStack.push(currentTree)
currentTree = currentTree.getRightChild()
elif word == ')':
currentTree = pStack.pop()
else:
raise ValueError('运算表达式出现问题：' + word)
return eTree
def buildParseTree(fpexp):
fplist = fpexp.split()
pStack = Stack()
eTree = BinaryTree('')
pStack.push(eTree)
currentTree = eTree
for i in fplist:
if i == '(':
currentTree.insertLeft('')
pStack.push(currentTree)
currentTree = currentTree.getLeftChild()
elif i not in '+-*/)':
currentTree.setRootVal(eval(i))
parent = pStack.pop()
currentTree = parent
elif i in '+-*/':
currentTree.setRootVal(i)
currentTree.insertRight('')
pStack.push(currentTree)
currentTree = currentTree.getRightChild()
elif i == ')':
currentTree = pStack.pop()
else:
raise ValueError("Unknown operator: " + i)
return eTree
def buildParseTree(fpexp):
####tokenize the expression to follow the rules:
fplist=fpexp.split()
pStack=Stack()
eTree=BinaryTree('')
pStack.push(eTree)
currentTree=eTree
for i in fplist:
if i == '(':
currentTree.insertLeft('')
pStack.push(currentTree)
currentTree=currentTree.getLeftChild()
elif i in ['+', '-', '*', '/']:
currentTree.setRootVal(i)
currentTree.insertRight('')
pStack.push(currentTree)
currentTree=currentTree.getRightChild()
elif i == ')':
currentTree=pStack.pop()
elif i not in ['+', '-', '*', '/',')']:
try:
currentTree.setRootVal(int(i))
parent=pStack.pop()
currentTree=parent
except ValueError:
raise ValueError("token '{}' is not a valid interger'.format(i))
return eTree
def buildParseTree(fpexp):
fplist = format_fpelist(fpexp)
# fplist = fpexp.split()
pStack = Stack()
eTree = BinaryTree('')
pStack.push(eTree)
currentTree = eTree
for i in fplist:
if i == '(':
currentTree.insertLeft('')
pStack.push(currentTree)
currentTree = currentTree.getLeftChild()
elif i not in ['+', '-', '*', '/', ')']:
currentTree.setRootVal(int(i))
parrent = pStack.pop()
currentTree = parrent
elif i in ['+', '-', '*', '/']:
currentTree.setRootVal(i)
currentTree.insertRight('')
pStack.push(currentTree)
currentTree = currentTree.getRightChild()
elif i == ')':
currentTree = pStack.pop()
else:
raise ValueError
return eTree
def bulidParseTree(fpexp):
'''
思路————
1. 首先，把全括号表达式 fpexp(有空格相间)拆分为单词 fplist 列表
其中单词分为括号 "()"、操作符 "+-*/" 和操作数 "0~9"
左括号就代表表达式开始，右括号是表达式的结束(即表达式最外层有一括号)
2. 从左到右扫描全括号表达式的每一个单词，依据规则建立解析树
1) 如果当前单词是 "(": 为当前节点添加一个新节点作为其左子节点，
当前节点下降，设这个节点为新节点
2) 如果当前单词是操作符 ['+','-','*','/']: 将当前节点的值设为此符号，
为当前节点添加一个新节点作为其右子节点，当前节点下降，设这个为新节点
3) 如果当前单词是操作数：将当前节点的值设为此数，当前节点上升返回到父节点
4) 如果当前单词是 ")": 则当前节点上升返回到父节点
其中，
当前节点创建左右子树，可以调用 BinaryTree.insertLeft/Right
当前节点设置值，可以调用 BinaryTree.setRootVal
当前节点下降到左右子树，可以调用 BinaryTree.getLeft/RightChild
但是，当前节点上升到父节点，这个没办法支持！
不妨使用一个栈来记录跟踪父节点
当前节点下降时，将下降前的节点 push 入栈
当前节点需要上升到父节点时，上升到 pop 出栈的节点即可
'''
fplist = fpexp.split()
pStack = Stack()
eTree = BinaryTree('')
pStack.push(eTree)
currentTree = eTree
for i in fplist:
if i == '(':
currentTree.insertLeft('')
pStack.push(currentTree)
currentTree = currentTree.getLeftChild()
elif i in ['+', '-', '*', '/']:
currentTree.setRootVal(i)
currentTree.insertRight('')
pStack.push(currentTree)
currentTree = currentTree.getRightChild()
elif i == ')':
currentTree = pStack.pop()
elif i not in ['+', '-', '*', '/', ')']:
try:
currentTree.setRootVal(int(i))
parent = pStack.pop()
currentTree = parent
except ValueError:
raise ValueError("token '{}' is not a valid integer".format(i))
return eTree
def buildParseTree(fpexp):
fplist = fpexp.split()
pStack = Stack()
eTree = BinaryTree('')
pStack.push(eTree)
currentTree = eTree
for i in fplist:
if i == '(': currentTree.insertLeft('')
pStack.push(currentTree)
currentTree = currentTree.getLeftChild()
elif i not in '+-*/)': currentTree.setRootVal(eval(i))
parent = pStack.pop()
currentTree = parent
def buildMathTree(self, expr):
tokens = self.parseExpr(expr)
pRoots = [] # list of parent roots
cRoot = self.mTree # current root
for c in tokens:
if c == '(':
cRoot.insertRight({
'val': '(',
})
pRoots.append(cRoot)
cRoot = cRoot.getRightChild()
elif c == ')':
while (pRoots[-1].getRootVal()['val'] != '('):
pRoots.pop()
openParen = pRoots.pop()
cRoot = pRoots.pop()
cRoot.rightChild = openParen.rightChild
else:
curr_pred = self.pred[cRoot.getRootVal()['val']]
new_pred = self.pred[c]
while (curr_pred >= new_pred):
cRoot = pRoots.pop()
curr_pred = self.pred[cRoot.getRootVal()['val']]
newNode = BinaryTree({
'val': c,
})
newNode.leftChild = cRoot.rightChild
cRoot.rightChild = newNode
pRoots.append(cRoot)
cRoot = newNode
self.mTree = pRoots[0].rightChild if len(
pRoots) > 0 else cRoot.rightChild
return self.mTree
def quotient_rule(currentNode, currentValue, dStack):
currentNode.Key = '/'
gTree = currentNode.getLeftChild()
dgTree = BinaryTree(currentNode.getLeftChild().key)
dgNode = dgTree
iStack = Stack()
build_tree(currentNode.getLeftChild(), dStack, dgNode, iStack)
dgTree = derivative(dgTree)
fTree = currentNode.getRIghtChild()
dfTree = BinaryTree(currentNode.getRightChild().key)
dfNode = dfTree
iStack = Stack()
build_tree(currentNode.getRightChild(), dStack, dgNode, iStack)
dfTree = derivative(dfTree)
quoTree = BinaryTree('/')
quoNode = quoTree
quoNode.insertleft('-')
quoNode.insertRight('^')
quoNode = quoNode.getRightChild
quoNode.insertRight('2')
quoNode.insertLeft(gTree)
quoNode.getLeftChild()
quoNode = quoNode.getLeftChild
quoNode.insertLeft('*')
quoNode.insertRight('*')
quoNode = quoNode.getRightChild
quoNode.insertRight(dgTree)
quoNode.insertLeft(fTree)
quoNode = dStack.pop()
quoNode.getLeftChild()
quoNode.insertRight(dfTree)
quoNode.insertLeft(gTree)
der_output(quoTree)
def build_test_tree():
root = BinaryTree('a')
root.insert_left('b')
root.insert_right('f')
lnode = root.left_child
lnode.insert_left('c')
lnode.insert_right('d')
lrnode = lnode.right_child
lrnode.insert_right('e')
rnode = root.right_child
rnode.insert_left('g')
return root
def __init__(self):
# Precedence of operators
self.pred = defaultdict(lambda: 10)
self.pred['('] = 1
self.pred[')'] = 1
self.pred['+'] = 2
self.pred['-'] = 2
self.pred['*'] = 3
self.pred['/'] = 3
# A node contains a string value that represents
# either an operator or a number.
# A node also can contain other information, if necessary.
# For example, if we run add_nterms(), then
# each node contains the number of terms at the subtree rooted at the node.
# The default root contains '(' as its value.
self.mTree = BinaryTree({
'val': '(',
})
else:
return tree.getRootVal()
# 还原完全括号表达式
def printExp(tree):
sumVal = ''
if tree:
currentVal = tree.getRootVal()
if isinstance(currentVal, int):
sumVal = printExp(tree.getLeftChild())
else:
sumVal = '(' + printExp(tree.getLeftChild())
sumVal = sumVal + str(tree.getRootVal())
if isinstance(currentVal, int):
sumVal = sumVal + printExp(tree.getRightChild())
else:
sumVal = sumVal + printExp(tree.getRightChild()) + ')'
return sumVal
etree = BinaryTree('*')
etree.insertRight(2)
etree.insertLeft(3)
preorder(etree)
print(printExp(etree))
print(postorderEval(etree))
from pythonds.trees import BinaryTree
r = BinaryTree('a')
a = r.getRootVal()
print(a)
print(r.getLeftChild())
r.insertLeft('b')
print(r.getLeftChild())
print(r.getLeftChild().getRootVal())
# 3. Using the findSuccesor method, write a non-recursive inorder traversal for a binary search tree.
from pythonds.basic import Stack
from pythonds.trees import BinaryTree
# Inorder traversal using a Stack
def inorderTrav(tree):
posStack = Stack()
current = tree
while current != None or posStack.size() > 0:
# Left-most node
while (current != None):
posStack.push(current)
current = current.getLeftChild()
current = posStack.pop()
print(current.getRootVal())
current = current.getRightChild()
tree = BinaryTree("A")
tree.insertLeft("B")
tree.getLeftChild().insertLeft("C")
tree.getLeftChild().insertRight("D")
tree.insertRight("E")
inorderTrav(tree)
def ParseTree(exp):
exp = exp.split()
expTree = BinaryTree('') # create an empty tree
parents = Stack() # create stack to hold the parents
parents.push(expTree) # root is kept on bttm of stack
for item in exp:
if item == '(': # next item will be var or int, followed by an operator - we need to move down
expTree.insertLeft(
''
) # insert empty node on left which will be a num or int later
parents.push(expTree)
expTree = expTree.getLeftChild(
) # move down so num or var can be placed
elif item == ')':
expTree = parents.pop()
elif item in OPERATORS:
expTree.key = item # operator is placed at current node
expTree.insertRight('')
parents.push(expTree)
expTree = expTree.getRightChild(
) # we move right because a symbol or an num must be placed next
elif item not in SYMBOLS and item not in OPERATORS and item != "(" and item != ")":
expTree.key = float(
item
) # entering them as float in case anyone inputs float values
expTree = parents.pop()
elif item in SYMBOLS:
expTree.key = item
expTree = parents.pop()
return expTree
# _*_ coding: utf-8 -*-
# @Time : 8/27/20 3:19 PM
# @Author : title_z
# @Filename : Binarytree.py
from pythonds.trees import BinaryTree
# r = BinaryTree(3)
# BinaryTree.insertLeft(r, 4)
# BinaryTree.insertLeft(r, 5)
# BinaryTree.insertRight(r, 6)
# BinaryTree.insertRight(r, 7)
# l = BinaryTree.getLeftChild(r)
# print(l)
r = BinaryTree('a')
r.insertLeft('b')
r.insertRight('c')
r.getRightChild().setRootVal('hello')
r.getLeftChild().insertRight('d')
print(r)
def __init__(self, rootObj):
BinaryTree.__init__(self, rootObj)
self.leftChildDer = None
self.rightChildDer = None
self.val = None