def test_1(self):
tree = create_tree([1, 2, 3, 4])
self.assertEqual(find(tree, 3), [[1, 2], [3]])
tree = create_tree([1, -2, -3, 4, 5, 4])
self.assertEqual(find(tree, 3), [[1, -2, 4], [-2, 5]])
return
def _print():
a1 = [1, None, 2, 3]
t1 = create_tree(a1)
a2 = [1, 2, 3]
t2 = create_tree(a2)
print(is_balanced(t1))
print(is_balanced(t2))
def test_1(self):
self.assertEqual(check(create_tree([2, 1, 3])), True)
self.assertEqual(check(create_tree([1, 3, 2, 4, 5])), False)
self.assertEqual(check(create_tree([20, 10, 30, None, 25])), False)
self.assertEqual(
check(create_tree([20, 10, 30, 5, 15, None, None, 3, 7, None,
17])), True)
return
def _print():
a1 = [2, 1, 3]
t1 = create_tree(a1)
a2 = [3, 1, 2]
t2 = create_tree(a2)
print(is_bst(t1))
print(is_bst(t2))
print(is_bst2(t1))
print(is_bst2(t2))
def _print():
a1 = [1, 2, 3, 4, 5]
a2 = [1, None, 3, None, 4]
t1 = create_tree(a1)
t2 = create_tree(a2)
r1 = create_level_linked_list2(t1)
r2 = create_level_linked_list2(t2)
for l in r1:
print(restore_list(l))
for l in r2:
print(restore_list(l))
def _print():
t1 = create_tree([3, 1, 5, None, None, 4, 8])
n3 = t1
n1 = n3.left
n5 = n3.right
n4 = n5.left
n8 = n5.right
n7 = create_tree([7])
res1 = lowest_common_ancestor(n3, n1, n8)
res2 = lowest_common_ancestor(n3, n4, n8)
res3 = lowest_common_ancestor(n3, n5, n8)
res4 = lowest_common_ancestor(n3, n5, n7)
print(res1.data, res2.data, res3.data, res4)
def _print():
t1 = create_tree([1, 2, 3, 4, 5])
t2 = create_tree([2, 4, 5])
t3 = create_tree([1, 2, 3])
t4 = create_tree([1, 2, 4])
t5 = create_tree([5])
print(contains_tree2(t1, t2))
print(contains_tree2(t1, t3))
print(contains_tree2(t1, t4))
print(contains_tree2(t1, t5))
print(contains_tree(t1, t2))
print(contains_tree(t1, t3))
print(contains_tree(t1, t4))
print(contains_tree(t1, t5))
def _print():
t1 = create_tree([1, 2, 3, 4, 5])
t2 = create_tree([2, 4, 5])
t3 = create_tree([1, 2, 3])
t4 = create_tree([1, 2, 4])
t5 = create_tree([5])
print(contains_tree2(t1, t2))
print(contains_tree2(t1, t3))
print(contains_tree2(t1, t4))
print(contains_tree2(t1, t5))
print(contains_tree(t1, t2))
print(contains_tree(t1, t3))
print(contains_tree(t1, t4))
print(contains_tree(t1, t5))
def test_1(self):
t1 = create_tree([1, 2, 3, 4, 5, 6])
t2 = create_tree([2, 4, 5])
self.assertEqual(is_partial_tree(t1, t2), True)
t2 = create_tree([2, 4])
self.assertEqual(is_partial_tree(t1, t2), False)
t2 = create_tree([4])
self.assertEqual(is_partial_tree(t1, t2), True)
self.assertEqual(is_partial_tree(None, t2), False)
self.assertEqual(is_partial_tree(t1, None), True)
return
def main():
# 读取
origin_labels = vector_data.get_labels()
data = vector_data.get_data()
# 深拷贝
labels = copy.deepcopy(origin_labels)
# data 为 pandas 类型
# data, origin_lables = vector_data.get_data_and_labels_from_file()
# labels = copy.deepcopy(origin_lables)
# 创建树
cart_tree = tree.create_tree(data, labels)
print cart_tree
sample_size = len(data)
error_count = 0
for element in data:
category = tree.classify_element(element[:-1], cart_tree,
origin_labels)
print '测试用例 ： ' + str(element[:-1]) + ', ' + '测试结果 : ' + str(
category) + ', ' + '实际结果 ：' + str(element[-1])
if category != element[-1]:
error_count += 1
print '错误率 ：' + str(fractions.Fraction(error_count, sample_size))
paint.create_plot(cart_tree)
def _test():
a1 = [1, 2, 3, 4, 5]
t1 = create_tree(a1)
ppath1 = []
ipath1 = []
preorder_path(t1, ppath1)
inorder_path(t1, ipath1)
print(ppath1)
print(ipath1)
def _test():
a1 = [1, 2, 3, 4, 5]
t1 = create_tree(a1)
ppath1 = []
ipath1 = []
preorder_path(t1, ppath1)
inorder_path(t1, ipath1)
print(ppath1)
print(ipath1)
def test_1(self):
result_list = []
create_depth_list(create_tree([1, 2, 3, 4, 5, 6, 7, 8]), result_list,
0)
self.assertEqual(len(result_list), 4)
self.assertEqual([v.data for v in result_list[0]], [1])
self.assertEqual([v.data for v in result_list[1]], [2, 3])
self.assertEqual([v.data for v in result_list[2]], [4, 5, 6, 7])
self.assertEqual([v.data for v in result_list[3]], [8])
return
def pop_generate(data, pres, abse, pop_size, variables, max_height):
"""
Creates a list of trees
"""
population = []
pop_fits = []
for i in range(0, pop_size):
n = create_tree(variables, max_height, data, pres, abse)
log(n) #prints n if verbose set to true
if log.is_verbose:
n.print_tree_data()
population.append(n)
log(n.fitness)
pop_fits.append(n.fitness)
population.sort(reverse=True)
avg_pop_fit = sum(pop_fits) / pop_size
sd_fit = np.std(pop_fits)
best_ind = population[0]
best_fit = population[0].fitness
return (population, avg_pop_fit, sd_fit, best_ind, best_fit)
def test_1(self):
tree = create_tree([1, 2, 3, 4, 5, 6])
node_a = tree.left.left
node_b = tree.left.right
expected = tree.left
self.assertEqual(search(tree, node_a, node_b), expected)
node_a = tree.right.left
node_b = tree.right
expected = tree.right
self.assertEqual(search(tree, node_a, node_b), expected)
node_a = tree.left.left
node_b = tree.right
expected = tree
self.assertEqual(search(tree, node_a, node_b), expected)
node_a = tree.left
node_b = TreeNode(100)
expected = None
self.assertEqual(search(tree, node_a, node_b), expected)
return
:return:
"""
if not root:
return []
stack = [root]
layer = []
while stack:
record = []
for _ in range(len(stack)):
node = stack.pop(0)
record.append(node.val)
if node.left:
stack.append(node.left)
if node.right:
stack.append(node.right)
layer.append(record)
return layer
if __name__ == '__main__':
input = [1, 2, 3, 4, 5]
tree = create_tree(input)
s = Solution()
out = s.levelOrder(tree)
print(out)
#
# 1
# 2 3
# 4 5
queue.appendleft(root)
from collections import defaultdict
tree_dic = defaultdict(lambda: 0)
level = 1
tree_dic[level] = 1
while len(queue):
level_count = tree_dic[level]
ind = 0
while level_count:
q = queue.pop()
level_count -= 1
if not q.left and not q.right:
return level
if q.left:
queue.appendleft(q.left)
tree_dic[level + 1] += 1
if q.right:
queue.appendleft(q.right)
tree_dic[level + 1] += 1
level += 1
return level
if __name__ == '__main__':
# [1, 2, 3, null, null, 4, null, null, 5]
node = create_tree([1, 2, 3, "null", "null", 4, "null", "null", 5])
sol = Solution()
print sol.minDepth(node)
pass
"""
:type root: TreeNode
:type sum: int
:rtype: bool
"""
rlist = []
def DFS(r, ls, s, ss):
if not r:
return
s += r.val
if not r.left and not r.right:
if s == ss:
rlist.append(ls + str(r.val))
ls = ls + str(r.val) + "->"
if r.left:
DFS(r.left, ls, s, ss)
if r.right:
DFS(r.right, ls, s, ss)
DFS(root, "", 0, sum)
if not len(rlist):
return False
else:
return True
if __name__ == '__main__':
from tree import create_tree
node = create_tree([-2, "null", -3])
sol = Solution()
print sol.hasPathSum(node, -5)
pass
def _print():
a1 = [1, 2, 3, 4, 5, None, None, -1]
t1 = create_tree(a1)
find_sum(t1, 3)
# -*- coding:utf-8 -*- import tree import treePlotter feature, labels = tree.create_data_set() # en = tree.calcShannomEnt(feature) # print en # print feature # print labels # feature[0][-1] = "maybe" # en2 = tree.calcShannomEnt(feature) # print feature # print en2 # split = tree.splitDataSet(feature,0, 0) # print tree.splitDataSet(feature,0, 0) # print tree.splitDataSet(feature,0, 1) # bestFeature = tree.chooseBestFeature(feature) # print bestFeature myTree = tree.create_tree(feature, labels) print myTree # treePlotter.createPlot() feature, labels = tree.create_data_set() pre = tree.classify(myTree, labels, [1, 0]) print pre
:type sum: int
:rtype: bool
"""
rlist = []
def DFS(r, ls, s, ss):
if not r:
return
s += r.val
if not r.left and not r.right:
if s == ss:
rlist.append(ls + str(r.val))
ls = ls + str(r.val) + "->"
if r.left:
DFS(r.left, ls, s, ss)
if r.right:
DFS(r.right, ls, s, ss)
DFS(root, "", 0, sum)
if not len(rlist):
return False
else:
return True
if __name__ == '__main__':
from tree import create_tree
node = create_tree([-2, "null", -3])
sol = Solution()
print sol.hasPathSum(node, -5)
pass
def main():
data_set, labels = tree.create_data_set()
my_tree = tree.create_tree(data_set, labels)
create_plot(my_tree)
my_data[0][-1] = 'maybe'
result = tree.calc_shannon_ent(my_data)
# 1.3709505944546687
print(result)
print('******' * 10)
my_data, class_labels = tree.create_dataset()
result = tree.split_dataset(my_data, 0, 1)
print(result)
result = tree.split_dataset(my_data, 0, 0)
print(result)
print('***###***' * 10)
# 寻找最好的特性来分割数据
best_feature = tree.choose_best_feature_to_split(my_data)
print(best_feature)
print('########' * 10)
# 构建树
my_data, class_labels = tree.create_dataset()
my_tree = tree.create_tree(my_data, class_labels)
print('+++++tree++++++')
print(my_tree)
# 统计叶子节点
print('+++++get_number_leafs++++++')
number_leafs = tree.get_number_leafs(my_tree)
print(number_leafs)
tree_depth = tree.get_tree_depth(my_tree)
print(tree_depth)
def isSameTree(self, p, q):
"""
:type p: TreeNode
:type q: TreeNode
:rtype: bool
"""
def isame(p, q):
if not p and not q:
return True
if not p or not q:
return False
if p.val != q.val:
return False
l = isame(p.left, q.left)
r = isame(p.right, q.right)
return l and r
return isame(p, q)
if __name__ == '__main__':
sol = Solution()
p = create_tree([1, 1])
q = create_tree([1, 1])
print sol.isSameTree(p, q)
pass
my_tree = tree_plotter.retrieve_tree(0)
#
# tree_plotter.get_num_leafs(my_tree)
#
# tree_plotter.get_tree_depth(my_tree)
tree_plotter.create_plot(my_tree)
data, labels = tree.create_dataset()
tree.classify(my_tree, labels, [1, 0])
tree.classify(my_tree, labels, [1, 1])
tree.store_tree(
'my_tree', "/home/zhangzhiliang/Documents/my_git/DATA-SCIENTIST-/"
"machine_learing_algorithm/machine_learning_in_action/3_decision_tree/classifierStorage.txt"
)
tree.load_tree(
"/home/zhangzhiliang/Documents/my_git/DATA-SCIENTIST-/"
"machine_learing_algorithm/machine_learning_in_action/3_decision_tree/classifierStorage.txt"
)
# 隐形眼镜
fr = open(
'/home/zhangzhiliang/Documents/my_git/DATA-SCIENTIST-/machine_learing_algorithm/'
'machine_learning_in_action/3_decision_tree/lenses.txt')
lenses = [inst.strip().split('\t') for inst in fr.readlines()]
lenses_feature = ['age', 'prescript', 'astigmatic', 'tearRate']
lenses_tree = tree.create_tree(lenses, lenses_feature)
tree_plotter.create_plot(lenses_tree)
def main():
data_set, labels = tree.create_data_set()
my_tree = tree.create_tree(data_set, labels)
create_plot(my_tree)
class Solution(object):
def isSameTree(self, p, q):
"""
:type p: TreeNode
:type q: TreeNode
:rtype: bool
"""
def isame(p, q):
if not p and not q:
return True
if not p or not q:
return False
if p.val != q.val:
return False
l = isame(p.left, q.left)
r = isame(p.right, q.right)
return l and r
return isame(p, q)
if __name__ == '__main__':
sol = Solution()
p = create_tree([1, 1])
q = create_tree([1, 1])
print sol.isSameTree(p, q)
pass
