Python TreeNode.TreeNode类代码示例

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

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

    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

 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]

 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

 def doit():
     val = next(vals)
     if val == "#":
         return None
     node = TreeNode(int(val))
     node.left = doit()
     node.right = doit()
     return node

 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

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