current = tree
            par = current.getParent()
            while par and par.getLeftChild() is not current:
                par = par.getParent()
            return par


def left_more(tree):
    if tree is None:
        return None
    else:
        while tree.getLeftChild():
            tree = tree.getLeftChild()
        return tree


if __name__=="__main__":
    r = BinaryTree(0)
    print "root:", (r.getRootVal())

    r.insertLeft(1)
    print "left child:", (r.getLeftChild().getRootVal())

    r.insertRight(3)
    print "right child:", (r.getRightChild().getRootVal())

    r.insertRight(5)
    print "right child:", (r.getRightChild().getRootVal())


    print find_next(r, 5)
@email: [email protected]

"""
from Tree import BinaryTree

def check_identical(T1, T2):
    if T1 is None and T2 is None:
        return True
    if T1 is None and T2 is not None or T1 is not None and T2 is None:
        return False
    else:
        if T1.getRootVal() != T2.getRootVal():
            return False
        q1 = check_identical(T1.getLeftChild(), T2.getLeftChild())
        q2 = check_identical(T1.getRightChild(), T2.getRightChild())
        return q1 and q2


if __name__=="__main__":
    r1 = BinaryTree(0)
    r1.insertLeft(1)
    r1.insertRight(3)
    r1.insertRight(5)

    r2 = BinaryTree(0)
    r2.insertLeft(1)
    r2.insertRight(3)
    r2.insertRight(5)

    print check_identical(r1, r2)
Ejemplo n.º 3
0
from Tree import BinaryTree, inorder, postorder, preorder
r = BinaryTree(1)
r.insertLeft(3)
r.insertRight(2)
r.insertLeft(5)
preorder(r)
        return 0
    else:
        left_height = check_height_reduce(tree.getLeftChild())
        if left_height == -1:
            return -1
        right_height = check_height_reduce(tree.getRightChild())
        if right_height == -1:
            return -1

        height_diff = left_height - right_height
        if height_diff > 1:
            return -1
        else:
            return max([left_height, right_height]) + 1


if __name__=="__main__":
    r = BinaryTree('a')
    print "root:", (r.getRootVal())
    r.insertLeft('b')
    print "left child:", (r.getLeftChild().getRootVal())
    r.insertRight('c')
    print "right child:", (r.getRightChild().getRootVal())
    r.insertRight('d')
    print "right child:", (r.getRightChild().getRootVal())
    r.insertLeft('e')
    #print "right child:", (r.getRightChild().getRootVal())


    print "traverse_node", traverse_node(r)
        if path[i-1]>path[i]:
            return False
    return True


def _valid_BST(root, path):
    if root is None:
        return None
    _valid_BST(root.getLeftChild(), path)
    path.append(root.getRootVal())
    _valid_BST(root.getRightChild(), path)
    return path




if __name__=="__main__":
    r = BinaryTree(20)
    print "root:", (r.getRootVal())

    r.insertLeft(10)
    print "left child:", (r.getLeftChild().getRootVal())

    r.insertRight(30)
    print "right child:", (r.getRightChild().getRootVal())

    r.getLeftChild().insertRight(25)
    print r.getLeftChild().getRightChild().getRootVal()

    print valid_BST(r)
		left = self.lowestCommonAncestor(root.leftChild, A, B)
		right = self.lowestCommonAncestor(root.rightChild, A, B)

		if left is not None and right is not None:
			return root
		if left is not None and right is None:
			return left
		if right is not None and left is None:
			return right
		return None


# Construct a binary tree to test
Node_3 = BinaryTree(3)
Node_3.insertLeft(5)
Node_3.insertRight(1)
Node_5 = Node_3.getLeftChild()
Node_1 = Node_3.getRightChild()

Node_5.insertLeft(6)
Node_6 = Node_5.getLeftChild()
Node_5.insertRight(2)
Node_2 = Node_5.getRightChild()

Node_2.insertLeft(7)
Node_7 = Node_2.getLeftChild()
Node_2.insertRight(4)
Node_4 = Node_2.getRightChild()

Node_1.insertLeft(0)