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 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_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)
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