def pruning_decision_tree_test():
# load data
X_train, y_train, X_test, y_test = data.sample_decision_tree_pruning()
# build the tree
dTree = decision_tree.ID3()
dTree.train(X_train, y_train)
# print
print('Your decision tree:')
Utils.printTree(dTree)
Utils.reducedErrorPruning(dTree, X_test, y_test)
print('Your decision tree after pruning:')
Utils.printTree(dTree)
def decision_tree_test():
features, labels = data.sample_decision_tree_data()
# build the tree
dTree = decision_tree.ID3()
dTree.train(features, labels)
# print
print('Your decision tree: ')
Utils.printTree(dTree)
# data
X_test, y_test = data.sample_decision_tree_test()
# testing
y_est_test = dTree.predict(X_test)
print('Your estimate test: ', y_est_test)
class Node(object):
def __init__(self, val):
self.val = val
self.left = None
self.right = None
def reconstruct_tree(preorder):
preorder = deque(preorder)
return reconstruct_tree_(preorder)
def reconstruct_tree_(preorder):
val = preorder.popleft()
if val is None:
return None
node = Node(val)
node.left = reconstruct_tree_(preorder)
node.right = reconstruct_tree_(preorder)
return node
preorder = [
'H', 'B', 'F', None, None, 'E', 'A', None, None, None, 'C', None, 'D',
None, 'G', 'I', None, None, None
]
root = reconstruct_tree(preorder)
printTree(root)
self.left = None
self.right = None
class Solution:
def buildTree(self, postorder: List[int], inorder: List[int]) -> TreeNode:
self.dic, self.po = {}, postorder
for i in range(len(inorder)):
self.dic[inorder[i]] = i
return self.recur(len(postorder) - 1, 0, len(inorder) - 1)
def recur(self, pre_root, in_left, in_right):
if in_left > in_right: return # 终止条件：中序遍历为空
print(pre_root)
root = TreeNode(self.po[pre_root]) # 建立当前子树的根节点
i = self.dic[self.po[pre_root]] # 搜索根节点在中序遍历中的索引，从而可对根节点、左子树、右子树完成划分。
root.left = self.recur(pre_root - (in_right - i) - 1, in_left,
i - 1) # 开启左子树的下层递归
root.right = self.recur(pre_root - 1, i + 1, in_right) # 开启右子树的下层递归
return root # 返回根节点，作为上层递归的左（右）子节点
if __name__ == '__main__':
# preorder = [3, 9, 20, 15, 7]
postorder = [9, 15, 7, 20, 3]
inorder = [9, 3, 15, 20, 7]
solution = Solution()
res_TreeNode = solution.buildTree(postorder, inorder)
res = printTree(res_TreeNode)
print(list(chain(*res)))
def largestBST(root):
largestBST_(root, float('-inf'), float('inf'))
printTree(largest_bst)
(i for i, a in enumerate(preorder_seq) if a > preorder_seq[0]),
len(preorder_seq))
root = TreeNode(preorder_seq[0])
root.left = rebuild_bst_from_preorder(preorder_seq[1:transition_point])
root.right = rebuild_bst_from_preorder(preorder_seq[transition_point:])
return root
def rebuild_bst_from_preorder2(preorder_seq):
def helper(left, right):
if not preorder:
return None
if not left <= preorder[0] <= right:
return None
root = TreeNode(preorder[0])
preorder.popleft()
root.left = helper(left, root.val)
root.right = helper(root.val, right)
return root
preorder = deque(preorder_seq)
return helper(float('-inf'), float('inf'))
preorder_seq = [43, 23, 37, 29, 31, 41, 47, 53]
printTree(rebuild_bst_from_preorder(preorder_seq))
print '----------------------------------'
printTree(rebuild_bst_from_preorder2(preorder_seq))
from utils import printTree
class Tree(object):
def __init__(self, x):
self.val = x
self.left = None
self.right = None
r = Tree(1)
r.left = Tree(2)
r.right = Tree(3)
r.left.left = Tree(4)
r.left.right = Tree(5)
r.right.left = Tree(6)
r.right.right = Tree(7)
def clone(root):
if not root: return None
r = Tree(root.val)
r.left = clone(root.left)
r.right = clone(root.right)
return r
printTree(r)
printTree(clone(r))
from utils import printTree, TreeNode
def min_height_bst_from_sorted_array(A):
if not A:
return None
mid = len(A) / 2
root = TreeNode(A[mid])
root.left = min_height_bst_from_sorted_array(A[:mid])
root.right = min_height_bst_from_sorted_array(A[mid + 1:])
return root
printTree(min_height_bst_from_sorted_array([2, 3, 5, 7, 11, 13, 17, 19, 23]))
# if target node has no successor, replace it with its left child
else:
self.replace_node(parent=target_parent,
old_child=target,
new_child=target.left)
return True
bst = BST()
bst.insert(7)
bst.insert(5)
bst.insert(9)
bst.insert(8)
bst.insert(8.5)
bst.insert(3)
bst.insert(6)
bst.insert(10)
bst.insert(15)
bst.insert(13)
bst.insert(2)
bst.insert(1)
print "before delete"
printTree(bst.root)
# bst.delete(5)
bst.delete(7)
printTree(bst.root)
from utils import printTree
class Tree(object):
def __init__(self, x):
self.val = x
self.left = None
self.right = None
r = Tree(6)
r.left = Tree(3)
r.right = Tree(4)
r.left.left = Tree(7)
r.left.right = Tree(3)
r.right.left = Tree(8)
r.right.right = Tree(1)
def flip(root):
if not root: return
root.left, root.right = root.right, root.left
flip(root.left)
flip(root.right)
printTree(r)
flip(r)
printTree(r)
# if target node has no successor, replace it with its left child else: self.replace_node(parent=target_parent, old_child=target, new_child=target.left) return True bst = BST() bst.insert(7) bst.insert(5) bst.insert(9) bst.insert(8) bst.insert(8.5) bst.insert(3) bst.insert(6) bst.insert(10) bst.insert(15) bst.insert(13) bst.insert(2) bst.insert(1) print "before delete" printTree(bst.root) # bst.delete(5) bst.delete(7) printTree(bst.root)
from utils import printTree class Tree(object): def __init__(self, x): self.val = x self.left = None self.right = None r = Tree(1) r.left = Tree(2) r.right = Tree(3) r.left.left = Tree(4) r.left.right = Tree(5) r.right.left = Tree(6) r.right.right = Tree(7) def clone(root): if not root: return None r = Tree(root.val) r.left = clone(root.left) r.right = clone(root.right) return r printTree(r) printTree(clone(r))
from utils import printTree from collections import deque class Node(object): def __init__(self, val): self.val = val self.left = None self.right = None def reconstruct_tree(preorder): preorder = deque(preorder) return reconstruct_tree_(preorder) def reconstruct_tree_(preorder): val = preorder.popleft() if val is None: return None node = Node(val) node.left = reconstruct_tree_(preorder) node.right = reconstruct_tree_(preorder) return node preorder = ['H', 'B', 'F', None, None, 'E', 'A', None, None, None, 'C', None, 'D', None, 'G', 'I', None, None, None] root = reconstruct_tree(preorder) printTree(root)
return None
# second arg is used when iterator is exhausted
transition_point = next((i for i, a in enumerate(preorder_seq) if a > preorder_seq[0]), len(preorder_seq))
root = TreeNode(preorder_seq[0])
root.left = rebuild_bst_from_preorder(preorder_seq[1:transition_point])
root.right = rebuild_bst_from_preorder(preorder_seq[transition_point:])
return root
def rebuild_bst_from_preorder2(preorder_seq):
def helper(left, right):
if not preorder:
return None
if not left <= preorder[0] <= right:
return None
root = TreeNode(preorder[0])
preorder.popleft()
root.left = helper(left, root.val)
root.right = helper(root.val, right)
return root
preorder = deque(preorder_seq)
return helper(float('-inf'), float('inf'))
preorder_seq = [43, 23, 37, 29, 31, 41, 47, 53]
printTree(rebuild_bst_from_preorder(preorder_seq))
print '----------------------------------'
printTree(rebuild_bst_from_preorder2(preorder_seq))
from utils import printTree class Tree(object): def __init__(self, x): self.val = x self.left = None self.right = None r = Tree(6) r.left = Tree(3) r.right = Tree(4) r.left.left = Tree(7) r.left.right = Tree(3) r.right.left = Tree(8) r.right.right = Tree(1) def flip(root): if not root: return root.left, root.right = root.right, root.left flip(root.left) flip(root.right) printTree(r) flip(r) printTree(r)
