Пример #1
0
 def test_rightSideView(self):
     s = LeetSolution()
     self.assertEqual([], s.rightSideView(None))
     root = TreeNode.makeTree([1, 2, 3, '#', 5, '#', 4])
     self.assertEqual([1, 3, 4], s.rightSideView(root))
     root = TreeNode.makeTree([1, 2, 3, '#', 5, '#', 4, 6])
     self.assertEqual([1, 3, 4, 6], s.rightSideView(root))
 def construct(l):
     if l is None or 0 == len(l):
         return None
     node = TreeNode(l[0])
     node.left = construct([i for i in l if i < node.val])
     node.right = construct([i for i in l if node.val < i])
     return node
    def build(self, inorder, postorder, startIndexInorder, endIndexInorder, startIndexPostorder, endIndexPostorder):

        if len(inorder) == 0 or len(inorder) != len(postorder) or startIndexInorder > endIndexInorder or startIndexPostorder > endIndexPostorder:
            return None

        # key concept to understand is, when reaching root of inorder,
        # count of all left children are the same as postorder

        rootNum = postorder[endIndexPostorder]
        count = 0

        while startIndexInorder + count <= endIndexInorder and inorder[startIndexInorder + count] != rootNum:
            count += 1

        # i is at root number, start copying
        root = TreeNode(rootNum)

        # @note:@memorize: here cannot use 'i - 1' as end of posterorder
        #                   eg. 2nd recursion, 'i - 1' = 1, that's for inorder
        #                   so it should be the ***count*** of how many nodes
        # root.left = self.build(inorder, postorder, startIndexInorder, i - 1, startIndexPostorder, i - 1)

        root.left = self.build(inorder, postorder, startIndexInorder, startIndexInorder + count - 1, startIndexPostorder, startIndexPostorder + count - 1)
        root.right = self.build(inorder, postorder, startIndexInorder + count + 1, endIndexInorder, startIndexPostorder + count, endIndexPostorder - 1)

        return root
Пример #4
0
def gen(l,r):
    if l> r:
        return [None]
    ans =[]
    for i in range(l,r+1):

        ltrees = gen(l,i-1)
        rtrees = gen(i+1,r)
        for j in range(len(ltrees)):
            for k in range(len(rtrees)):
                 root = TreeNode(i)
                 root.left = ltrees [j]
                 root.right = rtrees [k]
                 ans.append(root)

        # if ltrees != [None]:
        #     for lt in ltrees:
        #         root.left = lt
        #         if rtrees != [None]:
        #             for rt in rtrees:
        #                 root.right = rt
        #                 ans.append(root)
        #         else:
        #             root.right = None
        #             ans.append(root)
        # else:
        #     root.left = None
        #     if rtrees != [None]:
        #         for rt in rtrees:
        #             root.right = rt
        #             ans.append(root)
        #     else:
        #         root.right = None
        #         ans.append(root)
    return ans
Пример #5
0
 def linkNode(self, nodes, idx):
     if 0 == len(nodes):
         return None
     nodes[idx] = TreeNode(nodes[idx])
     nodes[idx].left = self.linkNode(nodes[:idx], idx // 2)
     nodes[idx].right = self.linkNode(nodes[idx + 1:], (len(nodes) - idx - 1 - 1) // 2)
     return nodes[idx]
Пример #6
0
 def test_inorder(self):
     root = TreeNode.makeTree([1, '#', 2, 3])
     self.assertEqual([1, 3, 2], BTTraversal.inorder(root))
     root = TreeNode.makeTree([1, 2, 3, 4, 5, '#', 6])
     self.assertEqual([4, 2, 5, 1, 3, 6], BTTraversal.inorder(root))
     root = TreeNode.makeTree([3, 1, 4, '#', 2, '#', 5, '#', '#', '#', 6])
     self.assertEqual([1, 2, 3, 4, 5, 6], BTTraversal.inorder(root))
    def buildTrees(self, start, end):

        if start > end:
            # @note:@memorize: should be something, [[]] or [None]
            # or the below for loop of left/right subtree will be skipped
            # return []
            return [None]

        if start == end: # reaching single node
            return [TreeNode(start)]

        result = []

        for i in range(start, end + 1): # end should be included
            # oneRoot = TreeNode(i) # @note: should be in inner loop
            leftSubtreeArray = self.buildTrees(start, i - 1)
            rightSubtreeArray = self.buildTrees(i + 1, end)

            for oneLeftSubtree in leftSubtreeArray:
                for oneRightSubtree in rightSubtreeArray:
                    # @note:@memorize: should be here, every append is a brand new tree
                    #                   or else, here is changing the reference for the same tree
                    oneRoot = TreeNode(i)
                    oneRoot.left = oneLeftSubtree
                    oneRoot.right = oneRightSubtree
                    result.append(oneRoot)

        return result
    def _build_tree(self, X, y):
        '''
        INPUT:
            - X: 2d numpy array
            - y: 1d numpy array
        OUTPUT:
            - TreeNode

        Recursively build the decision tree. Return the root node.
        '''

        node = TreeNode()
        index, value, splits = self._choose_split_index(X, y)

        if index is None or len(np.unique(y)) == 1:
            node.leaf = True
            node.classes = Counter(y)
            node.name = node.classes.most_common(1)[0][0]
        else:
            X1, y1, X2, y2 = splits
            node.column = index
            node.name = self.feature_names[index]
            node.value = value
            node.categorical = self.categorical[index]
            node.left = self._build_tree(X1, y1)
            node.right = self._build_tree(X2, y2)
        return node
Пример #9
0
def importJSONbusiness(dataFile):
    """
        parameters:
  dataFile - name of file containing business JSON objects

  returns:
  busData - list containing dictionaries representing Yelp businesses
  """

    busData = []
    rootNode = 0

    try:
        bus = open(dataFile)
    except IOError:
        print "Unable to open data file: ", dataFile
        return -1

    for line in bus:
        try:
            data = json.loads(line)
        except ValueError:
            print "Failed to convert JSON object to dictionary"
            return -1

        n = TreeNode()
        n.key = data["business_id"]
        n.value = data
        busData.append(n)
        if rootNode == 0:
            rootNode = n
        else:
            rootNode.insert(n)

    return (busData, rootNode)
    def buildTree(self, inorder, postorder):
        """
        :type inorder: List[int]
        :type postorder: List[int]
        :rtype: TreeNode
        """

        if len(inorder) == 0 or len(inorder) != len(postorder):
            return None

        print 'inorder: ', inorder
        print 'postorder: ', postorder

        # key concept to understand is, when reaching root of inorder,
        # count of all left children are the same as postorder

        rootNum = postorder[-1]
        i = 0

        while i < len(inorder) and inorder[i] != rootNum:
            i += 1

        # i is at root number, start copying
        root = TreeNode(rootNum)

        root.left = self.buildTree(copy.deepcopy(inorder[0: i]), copy.deepcopy(postorder[0: i]))

        # @note:@memorize: here is the key, need to skip root node:
        #                   for inorder, it's list[i], so 2 halves: [0:i] and [i+1:]
        #                   for postorder, it's list[-1], so 2 halves: [0:i] and [i: -1]
        # root.right = self.buildTree(copy.deepcopy(inorder[i + 1: ]), copy.deepcopy(postorder[i + 1: ]))
        root.right = self.buildTree(copy.deepcopy(inorder[i + 1: ]), copy.deepcopy(postorder[i: -1]))

        return root
 def sortedArrayToBSTRecur(self, nums):
     if nums is None or 0 == len(nums):
         return None
     mid = len(nums) // 2
     node = TreeNode(nums[mid])
     node.left = self.sortedArrayToBSTRecur(nums[:mid])
     node.right = self.sortedArrayToBSTRecur(nums[mid + 1:])
     return node
 def sortedArrayToBST(self, nums):
     if not nums:
         return None
     mid = len(nums) / 2
     root = TreeNode(nums[mid])
     root.left = self.sortedArrayToBST(nums[:mid])
     root.right = self.sortedArrayToBST(nums[mid+1:])
     return root
Пример #13
0
 def doit():
     val = next(vals)
     if val == "#":
         return None
     node = TreeNode(int(val))
     node.left = doit()
     node.right = doit()
     return node
def main():
    s = Solution()
    root = TreeNode(1)
    root.left = TreeNode(2)
    root.right = TreeNode(3)
    root.left.right = TreeNode(5)
    result = s.binaryTreePaths(root)
    print result
 def sortedArrayToBST(self, array):
     length = len(array)
     if length == 0: return None
     if length == 1: return TreeNode(array[0])
     root = TreeNode(array[length / 2])
     root.left = self.sortedArrayToBST(array[:length / 2])
     root.right = self.sortedArrayToBST(array[length / 2 + 1:])
     return root
Пример #16
0
 def test_preorder(self):
     self.assertEqual([], BTTraversal.preorder([]))
     root = TreeNode.makeTree([1, '#', 2, 3])
     self.assertEqual([1, 2, 3], BTTraversal.preorder(root))
     root = TreeNode.makeTree([1, 2, 2, '#', 3, '#', 3])
     self.assertEqual([1, 2, 3, 2, 3], BTTraversal.preorder(root))
     root = TreeNode.makeTree([3, 1, 2])
     self.assertEqual([3, 1, 2], BTTraversal.preorder(root))
Пример #17
0
 def merge(n1, n2):
     if n1 is None and n2 is None:
         return None
     node = TreeNode(0)
     node.val = n1.val if n1 else 0
     node.val += n2.val if n2 else 0
     node.left = merge(n1.left if n1 else None, n2.left if n2 else None)
     node.right = merge(n1.right if n1 else None, n2.right if n2 else None)
     return node
 def buildTree(self, inorder, postorder):
     if not inorder :
         return None
     root_val = postorder[-1]
     root = TreeNode(root_val)
     root_index = inorder.index(root_val)
     root.left = self.buildTree(inorder[:root_index],postorder[:root_index])
     root.right = self.buildTree(inorder[root_index + 1:],postorder[root_index  : -1])
     return root
 def __buildTree(i_l, i_r, p_l, p_r):
     if i_l > i_r:
         return None
     root_val = postorder[p_r]
     root = TreeNode(root_val)
     root_index = inorder[i_l:i_r+1].index(root_val)
     root.left = __buildTree(i_l, i_l+root_index-1, p_l, p_l+root_index-1)
     root.right = __buildTree(i_l+root_index+1, i_r, p_l+root_index, p_r-1)
     return root
Пример #20
0
 def sortedArrayToBST(self, num):
     if num == []:
         return None
     size = len(num)
     locate_root = int(size/2)
     root = TreeNode(num[locate_root])
     root.left = self.sortedArrayToBST(num[:locate_root])
     root.right = self.sortedArrayToBST(num[locate_root+1:])
     return root
 def buildTree(self, inorder, postorder):
     if inorder == []:
         return None
     root = TreeNode(postorder[len(postorder)-1])
     length = inorder.index(postorder[len(postorder)-1])
     if length != len(postorder)-1:
         root.right = self.buildTree(inorder[length+1:],postorder[length: len(postorder)-1])
     if length > 0:
         root.left = self.buildTree(inorder[:length],postorder[:length])
     return root
 def buildNode(_inorder, _postorder):
     if 0 == len(_inorder) and 0 == len(_postorder):
         return None
     if 1 == len(_inorder) and 1 == len(_postorder):
         return TreeNode(_postorder[-1])
     val = _postorder[-1]
     node, idx = TreeNode(val), _inorder.index(val)
     node.left = buildNode(_inorder[:idx], _postorder[:idx])
     node.right = buildNode(_inorder[idx + 1:], _postorder[idx:-1])
     return node
 def buildNode(_preorder, _inorder):
     if 0 == len(_preorder) and 0 == len(_inorder):
         return None
     if 1 == len(_preorder) and 1 == len(_inorder):
         return TreeNode(_preorder[0])
     val = _preorder[0]
     node, idx = TreeNode(val), _inorder.index(val)
     node.left = buildNode(_preorder[1:1 + idx], _inorder[:idx])
     node.right = buildNode(_preorder[1 + idx:], _inorder[1 + idx:])
     return node
Пример #24
0
 def create_Children(self, parentNode, moves):
 	parent = parentNode.access_Board()
 	for item in moves:
 		oldBoard = Board(True,parentNode.get_Board())
 		oldBoard = oldBoard.make_move(self.player_color, item[0], item[1])
 		minmaxvar = self.minmax_Opposite(parentNode.get_minmax())
 		a = random.randint(0,100)
 		newNode = TreeNode(oldBoard, minmaxvar, a)
 		newNode.set_move(item)
 		parentNode.create_Child(newNode)
 def buildTree(self, preorder, inorder):
     if preorder == []:
         return None
     root = TreeNode(preorder[0])
     length = inorder.index(preorder[0])
     if length != 0:
         root.left = self.buildTree(preorder[1:length+1],inorder[:length])
     if len(preorder) > length:
         root.right = self.buildTree(preorder[length+1:],inorder[length+1:])
     return root
Пример #26
0
    def buildTree(self, preorder, inorder):
        if len(preorder) == 0:
            return

        root = TreeNode(preorder[0])
        left_num = inorder.index(preorder[0])
        right_num = inorder.index(preorder[0])+1
        root.left = self.buildTree(preorder[1:left_num+1], inorder[:left_num])
        root.right = self.buildTree(preorder[right_num:], inorder[right_num:])
        return root
Пример #27
0
 def test002(self):
     s = Solution()
     root = TreeNode('root')
     nodeR = TreeNode('nodeR')
     root.right = nodeR
     
     n = s.maxDepth(root)
     print "input:\t", root
     print "expect:\t", 2
     print "output:\t", n
Пример #28
0
 def buildTreeRec(self, preorder, inorder, P, I, element):
     if element == 0:
         return None
     root = TreeNode(preorder[P])
     div = 0;
     for i in range(I, I + element):
         if inorder[i] == preorder[P]: break
         div += 1
     root.down = self.buildTreeRec(preorder, inorder, P + 1, I, div)
     root.right = self.buildTreeRec(preorder, inorder, P + div + 1, I + div + 1, element - 1 - div)
     return root
Пример #29
0
 def call(self):
     
     matched_identifier = self.match([TokenType.ID]) 
     if matched_identifier is not None:
         node = TreeNode(matched_identifier[1])
         if self.match([TokenType.LPAREN]) is not None:
             arguments = self.args()
             if arguments is not None and self.match([TokenType.RPAREN]) is not None:
                 node.addChild(arguments)
                 return node
     return None
Пример #30
0
 def construct(A):
     if A is None or 0 == len(A):
         return None
     maxIdx, maxVal = 0, A[0]
     for i, a in enumerate(A):
         if maxVal < a:
             maxIdx, maxVal = i, a
     root = TreeNode(maxVal)
     root.left = construct(A[:maxIdx])
     root.right = construct(A[maxIdx + 1:])
     return root
Пример #31
0
    def __checkUnkleIsRed__(self, node: TreeNode):
        unkle = node.getUnkle()
        if unkle is not None and unkle.isRed():
            node.parent.setBlackColor()
            unkle.setBlackColor()

            grandparent = node.getGrandParent()
            grandparent.setRedColor()
            self.__checkAfterInsert__(grandparent)
        else:
            self.__checkNodeAndParentBranchAndTurn__(node)
Пример #32
0
 def _add(self, node, val):
     if(val < node.val):
         if(node.left != None):
             self._add(node.left, val)
         else:
             node.left = TreeNode(val)
     else:
         if(node.right != None):
             self._add(val, node.right)
         else:
             node.right = TreeNode(val)
 def buildTree(self, inorder, postorder):
     if inorder == []:
         return None
     root = TreeNode(postorder[len(postorder) - 1])
     length = inorder.index(postorder[len(postorder) - 1])
     if length != len(postorder) - 1:
         root.right = self.buildTree(inorder[length + 1:],
                                     postorder[length:len(postorder) - 1])
     if length > 0:
         root.left = self.buildTree(inorder[:length], postorder[:length])
     return root
Пример #34
0
def A2(mot,n):
    """Renvoie la liste des anagrammes stricts composes au maximum de n mots"""
    
    global dico
    tree = TreeNode()
    t = time()
    for word in dico:
        if all([c in mot for c in word]) and len(word)<=len(mot):
            tree.add(word)#On ajoute uniquement les mots qui nous interressent
    print("construction arbre :", time() - t)
    return tree.searchAnaCompose(list(mot), tree,maxMot = n)
Пример #35
0
 def _insert(self, key, val, currentNode):
     if key < currentNode.key:
         if currentNode.hasLeftChild():
             self._insert(key, val, currentNode.leftChild)
         else:
             currentNode.leftChild = TreeNode(key, val, parent=currentNode)
     else:
         if currentNode.hasRightChild():
             self._insert(key, val, currentNode.rightChild)
         else:
             currentNode.rightChild = TreeNode(key, val, parent=currentNode)
Пример #36
0
 def _insert(self, value, node):
     if value >= node._value:
         if node._right_child == None:
             node._right_child = TreeNode(value)
         else:
             self._insert(value, node._right_child)
     else:
         if node._left_child == None:
             node._left_child = TreeNode(value)
         else:
             self._insert(value, node._left_child)
Пример #37
0
def createTestTree(depth):

	ranAt1 = int(random.random() * 10)
	ranVal1 = random.random() * 100
	head = TreeNode(ranAt1, ranVal1, None, None)

	if depth > 1:
		head.left = createTestTree(depth - 1)
		head.right = createTestTree(depth - 1)

	return head
Пример #38
0
def test(inpList, ansList):
    root = TreeNode.fromList(inpList)
    ans = TreeNode.fromList(ansList)

    s = Solution()
    s.recoverTree(root)
    if root != ans:
        print('mine')
        root.printTree()
        print('answer')
        ans.printTree()
Пример #39
0
 def _insert(self, value, currentNode):
     if value < currentNode.val:
         if currentNode.left == None:
             currentNode.left = TreeNode(value)
         else:
             self._insert(value, currentNode.left)
     if value > currentNode.val:
         if currentNode.right == None:
             currentNode.right = TreeNode(value)
         else:
             self._insert(value, currentNode.right)
Пример #40
0
 def _dfs1(root, index):
     if root.val > index:
         if root.left:
             _dfs1(root.left, index)
         else:
             root.left = TreeNode(index)
     else:
         if root.right:
             _dfs1(root.right, index)
         else:
             root.right = TreeNode(index)
Пример #41
0
    def buildTree(self, postorder, inorder):
        if len(postorder) == 0:
            return None


        root = TreeNode(postorder[-1])
        left_num = inorder.index(postorder[-1])

        root.left = self.buildTree(postorder[:left_num], inorder[:left_num])
        root.right = self.buildTree(postorder[left_num:-1], inorder[left_num+1:])
        return root
Пример #42
0
 def maximumBinaryTree(arr):
     if arr is None or 0 == len(arr):
         return None
     maxVal, maxIdx = arr[0], 0
     for i, a in enumerate(arr):
         if maxVal < a:
             maxVal, maxIdx = a, i
     node = TreeNode(maxVal)
     node.left = maximumBinaryTree(arr[:maxIdx])
     node.right = maximumBinaryTree(arr[maxIdx + 1:])
     return node
Пример #43
0
 def __buildTree(i_l, i_r, p_l, p_r):
     if i_l > i_r:
         return None
     root_val = postorder[p_r]
     root = TreeNode(root_val)
     root_index = inorder[i_l:i_r + 1].index(root_val)
     root.left = __buildTree(i_l, i_l + root_index - 1, p_l,
                             p_l + root_index - 1)
     root.right = __buildTree(i_l + root_index + 1, i_r,
                              p_l + root_index, p_r - 1)
     return root
Пример #44
0
def main():
    root = TreeNode(4)
    root.left, root.left.left, root.left.right = TreeNode(2), TreeNode(
        1), TreeNode(3)
    root.right, root.right.right = TreeNode(5), TreeNode(6)
    Solution().in_order_iterative(root)
    print('- ' * 50)
    Solution().in_order_recursive(root)
Пример #45
0
def loadFirstChildren(root, foundNodes, batchloadOn):
    # get immediate children
    # batch load nodes of each fetched edge
    if batchloadOn:
        batchLoadAttribute(root.dagnode.child_edges, "child_node")
    for edge in root.dagnode.child_edges:
        child_node = edge.child_node
        ctree_node = TreeNode(child_node)
        ctree_node.parent = root
        ctree_node.edge_label = edge.label
        root.children.append(ctree_node)
        foundNodes.add(child_node)
Пример #46
0
def construct(indexes):
    head = TreeNode(1)
    q = [head]
    for lVal, rVal in indexes:
        n = q.pop(0)
        if -1 != lVal:
            n.left = TreeNode(lVal)
            q.append(n.left)
        if -1 != rVal:
            n.right = TreeNode(rVal)
            q.append(n.right)
    return head
Пример #47
0
    def constructFromPrePost(self, pre: List[int],
                             post: List[int]) -> TreeNode:
        if not pre or not post:
            return None

        node = TreeNode(pre[0])
        if len(pre) != 1:
            x = post.index(pre[1]) + 1
            node.left = self.constructFromPrePost(pre[1:x + 1], post[0:x])
            node.right = self.constructFromPrePost(pre[x + 1:], post[x:-1])

        return node
Пример #48
0
    def increasingBST(self, root):
        def inorder(node):
            if node:
                yield from inorder(node.left)
                yield node.val
                yield from inorder(node.right)

        ans = cur = TreeNode(None)
        for v in inorder(root):
            cur.right = TreeNode(v)
            cur = cur.right
        return ans.right
Пример #49
0
        def build(beg1: int, end1: int, beg2: int, end2: int) -> TreeNode:
            if beg1 == end1:
                return None
            rootVal = postorder[end2 - 1]
            root = TreeNode(rootVal)

            for shift in range(end1 - beg1):
                if inorder[shift + beg1] == rootVal:
                    root.left = build(beg1, beg1 + shift, beg2, beg2 + shift)
                    root.right = build(beg1 + shift + 1, end1, beg2 + shift,
                                       end2 - 1)
            return root
Пример #50
0
def createDecisionTree(dataset: list):
    """
    决策树构造函数
    :param dataset:输入训练数据集
    :return: 返回当前决策树的root结点
    """
    # 创建树根节点
    tn = TreeNode(dataset)
    # 树根据数据集开始分裂
    tn.divide()
    # 返回最后分裂完成的决策树
    return tn
Пример #51
0
 def buildTree(self, inorder, postorder):
     # Memory Limit Exceeded
     if not inorder or not postorder:
         return None
     root_val = postorder[-1]
     root = TreeNode(root_val)
     root_index = inorder.index(root_val)
     root.left = self.buildTree(inorder[:root_index],
                                postorder[:root_index])
     root.right = self.buildTree(inorder[root_index + 1:],
                                 postorder[root_index:-1])
     return root
        def DFS(start, end):
            if start > end:
                return None
            if start == end:
                return TreeNode(nums[start])

            mid = (start + end) // 2
            node = TreeNode(nums[mid])
            node.left = DFS(start, mid - 1)
            node.right = DFS(mid + 1, end)

            return node
Пример #53
0
    def helper(self, A, start, end):
        if start > end:
            return None

        mid = start + (end - start) / 2
        root = TreeNode(A[mid])
        left = self.helper(A, start, mid - 1)
        right = self.helper(A, mid + 1, end)
        root.left = left
        root.right = right

        return root
Пример #54
0
def exh_search(a, n, s):
    nodes = []
    queue = Queue()
    node = TreeNode([0], [], 0, 0, a)
    queue.put(node)
    heapq.heappush(nodes, node)
    while True:
        u = queue.get()
        fr = u.v_to[-1] if u.v_to else 0
        for _node in range(n):
            if u.cur_matr[fr][_node] != float('inf'):
                new_cost = u.cur_matr[fr][
                    _node] - s + u.cost if _node not in u.v_from else u.cur_matr[
                        fr][_node] + u.cost
                new_to = copy.deepcopy(u.v_to)
                new_from = copy.deepcopy(u.v_from)
                new_matr = copy.deepcopy(u.cur_matr)
                if fr != 0 or not u.v_to == []:
                    new_from.append(u.v_to[-1])
                new_matr[fr][_node] = float('inf')
                new_level = u.level + 1 if _node not in u.v_from else u.level - 1
                new_to.append(_node)
                new_node = TreeNode(new_from, new_to, new_cost, new_level,
                                    new_matr)

                if not contain_node(nodes, new_node) and u.cost != float(
                        'inf') and not find_cycles(u):
                    heapq.heappush(nodes, new_node)
                    queue.put(new_node)

        if queue.empty():
            break

    for el in nodes:
        if el.v_to and a[el.v_to[-1]][0] == float('inf'):
            el.cost = float('inf')
        elif el.v_to:
            el.cost += a[el.v_to[-1]][0]

    nodes.sort(key=lambda elem: elem.cost)
    ans_node = nodes[0]
    if ans_node.cost < 0:
        print(-ans_node.cost)
        ans_node.v_from.append(ans_node.v_to[-1])
        ans_node.v_to.append(0)
        for i in range(len(ans_node.v_to)):
            print("{}->{}".format(ans_node.v_from[i] + 1,
                                  ans_node.v_to[i] + 1),
                  end="  ")
        print()
    else:
        print("{}")
Пример #55
0
 def __generateTrees(left, right):
     res = []
     if left > right:
         return [None]
     else:
         for mid in xrange(left, right + 1):
             for left_child in __generateTrees(left, mid - 1):
                 for right_child in __generateTrees(mid + 1, right):
                     root = TreeNode(mid)
                     root.left = left_child
                     root.right = right_child
                     res.append(root)
         return res
Пример #56
0
    def cloneTree(self, root):
        # Write your code here
        if root is None:
            return None

        copy = TreeNode(root.val)
        left_copy = self.cloneTree(root.left)
        right_copy = self.cloneTree(root.right)

        copy.left = left_copy
        copy.right = right_copy

        return copy
Пример #57
0
 def _put(self, key, val, current_node):
     if key < current_node.key:
         if current_node.has_left_child():
             self._put(key, val, current_node.left_child)
         else:
             current_node.left_child = TreeNode(key, val,
                 parent=current_node)
     else:
         if current_node.has_right_child():
             self._put(key, val, current_node.right_child)
         else:
             current_node.right_child = TreeNode(key, val,
                 parent=current_node)
Пример #58
0
        def _constructTree(start, end):
            if start > end or not inOrder:
                return None

            item = postOrder.pop()
            node = TreeNode(item)

            pos = index[item]

            node.right = _constructTree(pos+1, end)
            node.left = _constructTree(start, pos-1)

            return node
Пример #59
0
 def generate(first, last):
     trees = []
     for root in range(first, last + 1):
         lefts = generate(first, root - 1)
         rights = generate(root + 1, last)
         for left in lefts:
             for right in rights:
                 node = TreeNode(root)
                 node.left = left
                 node.right = right
                 trees += node,
                 # trees.append(node)
     return trees or [None]