binarytree1

Binary Trees(二叉树)
Motivation
• List: either search or insert can be efficient, but not both • Tree: efficient access and update • Binary tree: efficient for
A
B D E C F
H
I
Different binary trees
Full and Complete B Nhomakorabeanary Trees
Full binary tree: Each node is either a leaf or
internal node with exactly two non-empty children.
Complete binary tree: If the height of the tree is d,
then all leaves except possibly level d-1 are completely full. The bottom level has all nodes to the left side.
have two leaf nodes.
Induction Hypothesis: Assume any full binary tree T
containing n-1 internal nodes has n leaves.
Full Binary Tree Theorem (2)
Induction Step: Given tree T with n internal
Full Binary Tree Theorem (1)
Theorem: The number of leaves in a non-empty full binary tree is one more than the number of internal nodes.
Full Binary Tree Theorem (1)
Binary Tree Node ADT (1)
// Binary tree node abstract class template <typename E> class BinNode{ public: virtual ̃ BinNode() {} // Base destructor // Return the node’s value virtual E& element() = 0; // Set the node’s value virtual void setElement(const E&) = 0; // Return the node’s left child virtual BinNode* left() const = 0;
F
I
Binary Tree Example
Depth of a node: the length of the path from the root to the node Height of a tree: one more than the depth of the deepest node in the tree
Traversals (3)
• Preorder enumeration • Inorder enumeration • Postorder enumeration
• Level-order enumeration
Traversals (3)
• Preorder enumeration ABDCEGFHI • Inorder enumeration BDAGECHFI • Postorder enumeration DBGEHIFCA • Level-order enumeration ABCDEFGHI
Traversals (1)
Any process for visiting the nodes in some order is called a traversal. Any traversal that lists every node in the tree exactly once is called an enumeration of the tree’s nodes.
Traversals (5)
// Bad implementation template <typename E> void preorder2(BinNode<E>* subroot) { visit(subroot); // Perform some action if (subroot->left() != NULL) preorder2(subroot->left()); if (subroot->right() != NULL) preorder2(subroot->right()); }
Traversals (2)
• Preorder traversal: Visit each node before visiting its children. • Postorder traversal: Visit each node after visiting its children. • Inorder traversal: Visit the left subtree, then the node, then the right subtree. • Level-order traversal: Visit every node on a level before going to a lower level.
A
C D E F
H
I
Binary Tree Example
Path: if n1,n2,….nk is a A sequence of nodes in the tree such that ni is the B C parent of ni+1, then the sequence is called a path. E D The length of the path is k-1 H If there is a path from node R to node M, then R is an ancestor of M and M is a descendant of R
nodes, pick internal node I with two leaf children. Remove I’s children, call resulting tree T’.
By induction hypothesis, T’ is a full binary tree with n leaves. Restore I’s two children. The number of internal nodes has now gone up by 1 to reach n. The number of leaves has also gone up by 1.
A
B D E C F
H
I
Binary Tree Example
Parent: immediate predecessor of a node Children: immediate successor B of a node Edge: from a node to its children Node B and C are children of node A while node A is parents of node B and C
Traversals (4)
// Good implementation template <typename E> void preorder(BinNode<E>* subroot) { if (subroot == NULL) return; // Empty visit(subroot); // Perform some action preorder(subroot->left()); preorder(subroot->right()); }
Full Binary Tree Corollary
Theorem: The number of empty subtrees in a non-empty tree is one more than the number of nodes in the tree.
Proof: Replace each empty subtree with a leaf node. This is a full binary tree.
A
B D E C F
H
I
Binary Tree Example
Level: all node of depth d are at level d in the tree Leaf node: Any node has two empty children Internal node: Any node has at elast one nonempty children
Binary Tree Example
Node: A~H
Root: node that has no predecessor– Node A
Subtree: Left subtree consists of Node B and D Right subtree consists of Node C,E,F,H and I
– searching – describing math expressions – organizing information to drive compression algorithms –…
Binary Trees