Python Node.left方法代码示例

# 需要导入模块: from tree import Node [as 别名]
# 或者: from tree.Node import left [as 别名]
def main():
    root = Node(0)
    root.left = Node(-10)
    root.left.left = Node(-20)
    root.left.right = Node(-5)
    root.right = Node(10)
    root.right.right = Node(20)
    print get_tree_median(root)

# 需要导入模块: from tree import Node [as 别名]
# 或者: from tree.Node import left [as 别名]
def main():
    root = Node(0)
    root.left = Node(-10)
    root.left.left = Node(-20)
    root.left.right = Node(-5)
    root.left.left.right = Node(-15)
    root.right = Node(10)
    print lca(root, -15, -5)

# 需要导入模块: from tree import Node [as 别名]
# 或者: from tree.Node import left [as 别名]
def main():
    root = Node(0)
    root.left = Node(1)
    root.left.left = Node(2)
    root.right = Node(1)
    root.right.right = Node(2)
    root.right.right.right = Node(3)
    root.right.left = Node(2)
    print is_balanced(root)

# 需要导入模块: from tree import Node [as 别名]
# 或者: from tree.Node import left [as 别名]
def createMinTree(low,high):
	if(low>high):
		return
	mid = (low + high)/2
	data = treeElements[mid]
	node = Node(data)
	node.left = createMinTree(low,mid-1)
	node.right = createMinTree(mid+1,high)
	return node

# 需要导入模块: from tree import Node [as 别名]
# 或者: from tree.Node import left [as 别名]
def main():
    root = Node(0)
    root.left = Node(1)
    root.right = Node(2)
    root.left.left = Node(3)
    root.left.right = Node(4)
    root.right.left = Node(5)
    root.right.right = Node(6)
    for i in range(7):
        print bfs(root, i), "\n"

# 需要导入模块: from tree import Node [as 别名]
# 或者: from tree.Node import left [as 别名]
def build_tree(lst):
    if lst == []:
        return
    middle = len(lst) / 2
    left_list = lst[:middle]
    right_list = []
    if len(lst) > 1:
        right_list = lst[middle + 1:]
    node = Node(lst[middle])
    node.left = build_tree(left_list)
    node.right = build_tree(right_list)
    return node

# 需要导入模块: from tree import Node [as 别名]
# 或者: from tree.Node import left [as 别名]
def main():
    root = Node(0)
    root.left = Node(-2)
    root.left.right = Node(-1) 
    root.right = Node(1)
    root.right.right = Node(2)
    lists_dict = dict()
    fill_linked_lists_dict(root, lists_dict, 0)
    i = 0
    while i in lists_dict:
        lst = lists_dict[i]
        ll_node = lst.head
        while ll_node != None:
            print ll_node.data
            ll_node = ll_node.nxt
        i += 1
        print

# 需要导入模块: from tree import Node [as 别名]
# 或者: from tree.Node import left [as 别名]
def parse(data, ttable=None, treename=None):
    """
    Parse a newick string.

    *data* is any file-like object that can be coerced into shlex, or
    a string (converted to StringIO)

    *ttable* is a dictionary mapping node labels in the newick string
     to other values.

    Returns: the root node.
    """
    from tree import Node, Tree
    
    if type(data) in types.StringTypes:
        data = StringIO(data)
    
    start_pos = data.tell()
    tokens = Tokenizer(data)

    node = None; root = None
    lp=0; rp=0; rooted=1

    previous = None

    ni = 0 # node id counter (preorder) - zero-based indexing
    li = 0 # leaf index counter
    ii = 0 # internal node index counter
    pi = 0 # postorder sequence
    while 1:
        token = tokens.get_token()
        if token == ';' or token == tokens.eof:
            assert lp == rp, \
                   "unbalanced parentheses in tree description: (%s, %s)" \
                   % (lp, rp)
            break

        # internal node
        elif token == '(':
            lp = lp+1
            newnode = Node()
            newnode.ni = ni; ni += 1
            ## newnode.isleaf = False
            newnode.treename = treename
            if node:
                if node.children: newnode.left = node.children[-1].right+1
                else: newnode.left = node.left+1
                node.add_child(newnode)
            else:
                newnode.left = 1
            newnode.right = newnode.left+1
            node = newnode

        elif token == ')':
            rp = rp+1
            node = node.parent
            if node.children:
                node.right = node.children[-1].right + 1
            
        elif token == ',':
            node = node.parent
            if node.children:
                node.right = node.children[-1].right + 1
            
        # branch length
        elif token == ':':
            token = tokens.get_token()
            if token == '[':
                node.length_comment = tokens.parse_embedded_comment()
                token = tokens.get_token()

            if not (token == ''):
                try: brlen = float(token)
                except ValueError:
                    raise ValueError, ("invalid literal for branch length, "
                                       "'%s'" % token)
            else:
                raise 'NewickError', \
                      'unexpected end-of-file (expecting branch length)'

            node.length = brlen
        # comment
        elif token == '[':
            node.comment = tokens.parse_embedded_comment()
            if node.comment[0] == '&':
                # metadata
                meta = META.findall(node.comment[1:])
                if meta:
                    node.meta = {}
                    for k, v in meta:
                        v = eval(v.replace('{','(').replace('}',')'))
                        node.meta[k] = v

        # leaf node or internal node label
        else:
            if previous != ')': # leaf node
                if ttable:
                    try:
                        ttoken = (ttable.get(int(token)) or
                                  ttable.get(token))
#.........这里部分代码省略.........

# 需要导入模块: from tree import Node [as 别名]
# 或者: from tree.Node import left [as 别名]
    def _fit_recursive(self, X, cluster, node=None):
        """Recursive helper for fit()

        skkdj

        Parameters
        ----------

        Returns
        -------
        """
        if X.shape[0] < 2:
            # base case
            # must have > 2 obs to cluster!
            return Node(self.Leaf(cluster.name, cluster.indices))

        # ---------------------------------------------------------------------
        # use ward w/ (1-corr) to hierarcically cluster to split
        # ---------------------------------------------------------------------
        split = _ward_cluster(X)

        # ---------------------------------------------------------------------
        # train/test svm (radial kernal on 100 random 50/50 splits of clustering
        # ---------------------------------------------------------------------
        try:
            scores = _test_clusters(X, split, stratified=self.stratified)
        except ValueError:
            # base case
            # two few of second class to split (say 9:1 or something)
            # assign entire population to terminal cluster
            return Node(self.Leaf(cluster.name, cluster.indices))

        # ---------------------------------------------------------------------
        # if min(score) < tol (0.80 in glif paper), recursively repeat 3-5 on
        # each subpopulation
        # ---------------------------------------------------------------------
        score = scores.min()
        if score < self.tol:
            # base case
            # assign entire population to terminal cluster
            return Node(self.Leaf(cluster.name, cluster.indices))


        # recursively split
        a = np.where(split == 1)
        b = np.where(split == 2)

        A = self.Cluster(cluster.indices[a], score, cluster.name + "1", len(a[0]))
        B = self.Cluster(cluster.indices[b], score, cluster.name + "2", len(b[0]))

        # add score to binary tree
        if node is None:
            node = Node(self.Split(cluster.name, (A.name, B.name), score, cluster.size))
        else:
            # tree is built pre order
            raise ValueError("Should be null!!!")

        node.left = self._fit_recursive(X[a], A, node.left)
        node.right = self._fit_recursive(X[b], B, node.right)

        return node