Trees
Binary Binary Trees
1
A binary tree is either empty, or it consists of a node called the root together with two binary trees called the left subtree and the right subtree of the root, which are disjoint from each other and from the root.
For example:
root node
Jargon:
level: 0 1 2
internal node
edge
leaf node
Computer Science Dept Va Tech June 2006
Data Structures & OO Development I
2006 McQuain & Ribbens
Binary Tree Node Relationships
A binary tree node may have 0, 1 or 2 child nodes. A path is a sequence of adjacent (via the edges) nodes in the tree.
Binary Trees
2
A subtree of a binary tree is either empty, or consists of a node in that tree and all of its descendent nodes.
parent node of and
child nodes of
a descendant of and
subtree rooted at
Computer Science Dept Va Tech June 2006
Data Structures & OO Development I
2006 McQuain & Ribbens
Quick Application: Expression Trees
A binary tree may be used to represent an algebraic expression:
*
Binary Trees
3
x
Each subtree represents a part of the entire expression If we visit the nodes of the binary tree in the correct order, we will construct the algebraic expression:
x
+
5
y
x (( x + y ) 5)
Computer Science Dept Va Tech June 2006
Data Structures & OO Development I
2006 McQuain & Ribbens
Traversals
Binary Trees
4
A traversal is an algorithm for visiting some or all of the nodes of a binary tree in some defined order. A traversal that visits every node in a binary tree is called an enumeration.
preorder:
visit the node, then the left subtree, then the right subtree
postorder: visit the left subtree, then the right subtree, and then the node
inorder:
visit the left subtree, then the node, then the right subtree
2006 McQuain & Ribbens
Computer Science Dept Va Tech June 2006
Data Structures & OO Development I
Postorder Traversal Details
Consider the postorder traversal from a recursive perspective: postorder: postorder visit the left subtree, postorder visit the right subtree, then visit the node (no recursion)
Binary Trees
5
If we start at the root:
POV sub() visit | POV sub() | visit
POV sub() | POV sub() | visit
visit | visit | visit
visit
Computer Science Dept Va Tech June 2006
Data Structures & OO Development I
2006 McQuain & Ribbens
Full and Complete Binary Trees
Binary Trees
6
Here are two important types of binary trees. Note that the definitions, while similar, are logically independent.
Full but not complete.
Definition:
a binary tree T is full if each node is either a leaf or possesses exactly two child nodes.
Definition:
a binary tree T with n levels is complete if all levels except possibly the last are completely full, and the last level has all its nodes to the left side.
Complete but not full.
Neither complete nor full.
Full and complete.
Computer Science Dept Va Tech June 2006
Data Structures & OO Development I
2006 McQuain & Ribbens
Full Binary Tree Theorem
Theorem: (a) (b) (c) (d) (e) (f) Let T be a nonempty, full binary tree Then:
Binary Trees
7
If T has I internal nodes, the number of leaves is L = I + 1. If T has I internal nodes, the total number of nodes is N = 2I + 1. If T has a total of N nodes, the number of internal nodes is I = (N 1)/2. If T has a total of N nodes, the number of leaves is L = (N + 1)/2. If T has L leaves, the total number of nodes is N = 2L 1. If T has L leaves, the number of internal nodes is I = L 1.
Basically, this theorem says that the number of nodes N, the number of leaves L, and the number of internal nodes I are related in such a way that if you know any one of them, you can determine the other two.
Computer Science Dept Va Tech June 2006
Data Structures & OO Development I
2006 McQuain & Ribbens
Proof of Full Binary Tree Theorem
Binary Trees
8
proof of (a):We will use induction on the number of internal nodes, I. Let S be the set of all integers I 0 such that if T is a full binary tree with I internal nodes then T has I + 1 leaf nodes. For the base case, if I = 0 then the tree must consist only of a root node, having no children because the tree is full. Hence there is 1 leaf node, and so 0 S. Now suppose that for some integer K 0, every I from 0 through K is in S. That is, if T is a nonempty binary tree with I internal nodes, where 0 I K, then T has I + 1 leaf nodes. Let T be a full binary tree with K + 1 internal nodes. Then the root of T has two subtrees L and R; suppose L and R have IL and IR internal nodes, respectively. Note that neither L nor R can be empty, and that every internal node in L and R must have been an internal node in T, and T had one additional internal node (the root), and so K + 1=IL + IR + 1. Now, by the induction hypothesis, L must have IL+1 leaves and R must have IR+1 leaves. Since every leaf in T must also be a leaf in either L or R, T must have IL + IR + 2 leaves. Therefore, doing a tiny amount of algebra, T must have K + 2 leaf nodes and so K + 1 S. Hence by Mathematical Induction, S = [0, ). QED
Computer Science Dept Va Tech June 2006
Data Structures & OO Development I
2006 McQuain & Ribbens
Limit on the Number of Leaves
Theorem:
Binary Trees
9
Let T be a binary tree with levels. Then the number of leaves is at most 2-1.
proof: We will use strong induction on the number of levels, . Let S be the set of all integers 1 such that if T is a binary tree with levels then T has at most 2-1 leaf nodes. For the base case, if = 1 then the tree must have one node (the root) and it must have no child nodes. Hence there is 1 leaf node (which is 2-1 if = 1), and so 1 S. Now suppose that for some integer K 1, all the integers 1 through K are in S. That is, whenever a binary tree has M levels with M K, it has at most 2M-1 leaf nodes. Let T be a binary tree with K + 1 levels. If T has the maximum number of leaves, T consists of a root node and two nonempty subtrees, say S1 and S2. Let S1 and S2 have M1and M2 levels, respectively. Since M1 and M2 are between 1 and K, each is in S by the inductive assumption. Hence, the number of leaf nodes in S1 and S2 are at most 2K-1 and 2K-1, respectively. Since all the leaves of T must be leaves of S1 or of S2, the number of leaves in T is at most 2K-1 + 2K-1 which is 2K. Therefore, K + 1 is in S. Hence by Mathematical Induction, S = [1, ). QED
Computer Science Dept Va Tech June 2006
Data Structures & OO Development I
2006 McQuain & Ribbens
More Useful Facts
Theorem:
Binary Trees 10
Let T be a binary tree. For every k 0, there are no more than 2k nodes in level k.
Theorem:
Let T be a binary tree with levels. Then T has no more than 2 1 nodes.
Theorem:
Let T be a binary tree with N nodes. Then the number of levels is at least log (N + 1).
Theorem:
Let T be a binary tree with L leaves. Then the number of levels is at least log L + 1.
Computer Science Dept Va Tech June 2006
Data Structures & OO Development I
2006 McQuain & Ribbens
Binary Tree Representation
Binary Trees 11
The natural to way think of a binary tree is that it consists of nodes (objects) connected by edges (pointers). This leads to a design employing two classes:
-
binary tree class binary node class
to encapsulate the tree and its operations to encapsulate the data elements, pointers and associated operations.
Each should be a template, for generality. The node class may handle all direct accesses of the pointers and data element, or allow its client (the tree) free access. The tree class may maintain a sense of a current location (node) and must provide all the high-level functions, such as searching, insertion and deletion.
Many implementations use a struct type for the nodes. The motivation is generally to make the data elements and pointers public and hence to simplify the code, at the expense of automatic initialization via a constructor.
Computer Science Dept Va Tech June 2006
Data Structures & OO Development I
2006 McQuain & Ribbens
A Binary Node Interface
Here's a possible interface for a binary tree node:
template <typename T> class BinNodeT { public: T Element; BinNodeT<T>* Left; BinNodeT<T>* Right; BinNodeT(); BinNodeT(const T& D, BinNodeT<T>* L = NULL, BinNodeT<T>* R = NULL); bool isLeaf() const; ~BinNodeT(); };
Binary Trees 12
Binary tree object can access node data members directly.
Useful for tree navigation.
The design here leaves the data members public to simplify the implementation of the encapsulating binary tree class; due to that encapsulation there is no concern that client code will be able to take advantage of this decision. The data element is stored by pointer to provide for storing dynamically allocated elements, and elements from an inheritance hierarchy. Converting to direct storage is relatively trivial.
Computer Science Dept Va Tech June 2006
Data Structures & OO Development I
2006 McQuain & Ribbens
A Binary Tree Class Interface
Binary Trees 13
Here's a possible interface for a binary tree class. It's not likely to be put to any practical use, just a proof of concept.
template <typename T> class BinaryTreeT { protected: BinNodeT<T>* Root; Recursive "helper" functions each has a corresponding public function.
unsigned int SizeHelper(BinNodeT<T>* sRoot) const; unsigned int HeightHelper(BinNodeT<T>* sRoot) const; bool InsertHelper(const T& D, BinNodeT<T>* sRoot); bool DeleteHelper(const T& D, BinNodeT<T>* sRoot); void TreeCopyHelper(BinNodeT<T>* TargetRoot, BinNodeT<T>* SourceRoot); T* const FindHelper(const T& toFind, BinNodeT<T>* sRoot); const T* const FindHelper(const T& toFind, BinNodeT<T>* sRoot) const; void DisplayHelper(BinNodeT<T>* sRoot, std::ostream& Out, unsigned int Level); void ClearHelper(BinNodeT<T>* sRoot); Virtual functions are used to encourage public: subclasses. BinaryTreeT(); BinaryTreeT(const T& D); BinaryTreeT(const BinaryTreeT<T>& Source); BinaryTreeT<T>& operator=(const BinaryTreeT<T>& Source); // . . . continued . . .
Computer Science Dept Va Tech June 2006
Data Structures & OO Development I
2006 McQuain & Ribbens
A Binary Tree Class Interface
// . . . continued . . . bool Insert(const T& D); bool Delete(const T& D); T* const Find(const T& D); const T* const Find(const T& D) const; unsigned int Size() const; unsigned int Height() const; void Display(std::ostream& Out); void Clear(); ~BinaryTreeT(); };
Binary Trees 14
Data insertion/search functions. Reporters, a display function, and a clear function.
The interface is somewhat incomplete since it's not really a serious class as we will see, specialized binary trees are what we really want. Still, there are some useful things we can learn from even an incomplete version
Computer Science Dept Va Tech June 2006
Data Structures & OO Development I
2006 McQuain & Ribbens
Finding a Data Element
template <typename T> T* const BinaryTreeT<T>::Find(const T& toFind) { if (Root == NULL) return NULL; return (FindHelper(toFind, Root)); }
Binary Trees 15
Nonrecursive interface function for client uses a recursive protected function to do almost all the work.
Why? template <typename T> T* const BinaryTreeT<T>::FindHelper(const T& toFind, BinNodeT<T>* sRoot) { T* Result; if (sRoot == NULL) return NULL;
Which traversal is used here?
if (sRoot->Element == toFind) { Why not use a different traversal Result = &(sRoot->Element); instead? } else { Result = FindHelper(toFind, sRoot->Left); if (Result == NULL) Result = FindHelper(toFind, sRoot->Right); Why is const used on } the return value?? return Result; }
Computer Science Dept Va Tech June 2006
Data Structures & OO Development I
2006 McQuain & Ribbens
Clearing the Tree
Binary Trees 16
Similar to the class destructor, Clear() causes the deallocation of all the tree nodes and the resetting of Root and Current to indicate an empty tree.
template <typename T> void BinaryTreeT<T>::Clear() { ClearHelper(Root); Root = NULL; } template <typename T> void BinaryTreeT<T>::ClearHelper(BinNodeT<T>* sRoot) { if (sRoot == NULL) return; ClearHelper(sRoot->Left); ClearHelper(sRoot->Right); delete sRoot; } Which traversal is used here? Why not use a different traversal instead?
Computer Science Dept Va Tech June 2006
Data Structures & OO Development I
2006 McQuain & Ribbens
Inorder Printing
template <typename T> void BinaryTreeT<T>::Display(ostream& Out) { if (Root == NULL) { Out << "tree is empty" << endl; return; } DisplayHelper(Root, Out, 0); }
Binary Trees 17
Inorder traversal: 3 left 1 4 0 5 2 7 6 right 8
template <typename T> void BinaryTreeT<T>::DisplayHelper(BinNodeT<T>* sRoot, ostream& Out, unsigned int Level) { if (sRoot == NULL) return; DisplayHelper(sRoot->Left, Out, Level + 1); if ( Level > 0 ) Out << setw(3*Level) << ' '; Out << sRoot->Element << endl; DisplayHelper(sRoot->Right, Out, Level + 1); }
QTP: Could we reverse the sides of the printed tree?
Computer Science Dept Va Tech June 2006
Data Structures & OO Development I
2006 McQuain & Ribbens
Summary of Implementation
Binary Trees 18
The implementation described here is primarily for illustration. The full implementation has been tested, but not thoroughly. As we will see in the next chapter, general binary trees are not often used in applications. Rather, specialized variants are derived from the notion of a general binary tree, and THOSE are used.
Before proceeding with that idea, we need to establish a few facts regarding binary trees.
Warning: the binary tree classes given in this chapter are intended for instructional purposes. The given implementation contains a number of known flaws, and perhaps some unknown flaws as well. Caveat emptor.
Computer Science Dept Va Tech June 2006
Data Structures & OO Development I
2006 McQuain & Ribbens