Post on 15-Jan-2016
1
Binary TreesBinary Trees Binary Search TreesBinary Search Trees
CSE 30331Lecture 13 –Trees
2
Reading
Binary Trees Ford: Ch 10
3
Tree Structures
President-CEO
ProductionManager
SalesManager
ShippingSupervisor
PersonnelManager
WarehouseSupervisor
PurchasingSupervisor
HIERARCHICAL TREE STRUCTURE
4
Tree Structures
+
e
/
ba
*
dc
-
B IN ARY EXPRES S IO N T REE FO R " a* b + (c -d ) / e "
5
Tree Structures
A
JI
HGFE
DCB
(a)
(b )
A G EN ERAL T REE
6
Tree Terminology Node – location containing value(s) Parent – node 1 link above “here” in tree Child – node 1 link below “here” in tree Root – top (first) node in tree Leaf – A node without any children Interior node – any non-leaf node Ancestor – any node on a path between root and “here” Descendent – any node reachable by a path from “here”
downward in tree Level – number of links traversed from root to “here” Height (depth) – length of longest path from root to any leaf Subtree – Any node (chosen as root) along with all of its
descendents
7
Tree Node Level and Path Length
A
HG
FE
DCB
L e ve l: 0
L e ve l: 1
L e ve l: 2
L e ve l: 3
8
Binary Tree Definition
A binary tree T is a finite set of nodes with one of the following properties: (a) T has no nodes (it is the empty tree). (b) The set consists of …
a root R a left subtree TL
a right subtreeTR.
9
Samples of Binary Trees
A
E
D
C
B
A
F
H
ED
CB
I
T ree ASiz e 9 D ep t h 3
T ree BSiz e 5 D ep t h 4
G
10
Tree Node Level and Path Length – Depth Discussion
A
ED
CB
GF
JIH
C o m p let e T ree (D ep t h 3 )
11
Tree Node Level and Path Length – Depth Discussion
A
ED
CB
GF
Complete Tree (Depth 2)Also a full binary tree.
Contains maximum number of leaves
12
Tree Node Level and Path Length – Depth Discussion
A
ED
CB
IH
N o n -C o m p let e T ree (D ep t h 3 )Lev el 2 is m is s in g n o d es
13
Tree Node Level and Path Length – Depth Discussion
A
ED
CB
GF
KIH
N o n -C o m p let eT ree (D ep t h 3 )N o d es at lev el 3 d o n o t o ccu rp y left m o s t p o s it io n s
14
Binary Tree Nodes
Abs tract T re e M ode l
A
E F
H
D
CB
G
l e ft A ri gh t
T re e N ode M ode l
l e ft B ri gh t
l e ft E ri gh t
l e ft G ri gh t
l e ft D ri gh t
l e ft C ri gh t
l e ft H ri gh t
l e ft F ri gh t
15
Tree Node Classtemplate <typename T>class tnode{ public:
// public data simplifies building class functions T nodeValue; tnode<T> *left, *right;
// default constructor. data not initialized tnode() {}
// initialize the data members tnode (const T& item, tnode<T> *lptr = NULL, tnode<T> *rptr = NULL) : nodeValue(item), left(lptr), right(rptr) {}};
16
Tree Traversals
A
F
H
ED
CB
I
Tree ASize 9 Depth 3
G
Inorder: D B H E I A F C G
Postorder: D H I E B F G C A
Preoder: A B D E H I C F G
Level-Order: A B C D E F G H I
17
Inorder Traversal
Algorithm (1) traverse left subtree (2) process root (3) traverse right subtree
// version to output values in tree “inorder”
template <typename T>void inorderOutput(tnode<T> *t, const string& separator = " "){ if (t != NULL) { inorderOutput(t->left, separator); // descend left cout << t->nodeValue << separator; // output the node inorderOutput(t->right, separator); // descend right }}
18
Postorder TraversalAlgorithm (1) traverse left subtree (2) traverse right subtree (3) process root
// version to output values in tree “postorder”
template <typename T>void postorderOutput(tnode<T> *t, const string& separator = " "){ if (t != NULL) { postorderOutput(t->left, separator); // descend left postorderOutput(t->right, separator); // descend right cout << t->nodeValue << separator; // output the node }}
19
Preorder TraversalAlgorithm (1) process root (2) traverse left subtree (3) traverse right subtree
// version to output values in tree “preorder”
template <typename T>void preorderOutput(tnode<T> *t, const string& separator = " "){ if (t != NULL) { cout << t->nodeValue << separator; // output the node postorderOutput(t->left, separator); // descend left postorderOutput(t->right, separator); // descend right }}
20
Level-order traversal
Similar to breadth-first search
Traverses each level of the tree, in turn, from left to right
AlgorithmPush root on queueWhile queue not empty
pop node from queueprocess nodepush left and right child of node onto queue
21
Level-order Traversaltemplate <typename T>void levelorderOutput(tnode<T> *t, const string& separator = " "){ // store siblings of each node in a queue so that they are // after parent, and in order for next level of tree queue<tnode<T> *> q; tnode<T> *p;
q.push(t); // start by pushing root (t) onto queue while(!q.empty()) { p = q.front(); // process front queue node q.pop(); cout << p->nodeValue << separator; if(p->left != NULL) q.push(p->left); // push left child in queue if(p->right != NULL) q.push(p->right); // push right child on queue }}
22
Node Density
Full Tree (to depth k, or level k)
2k+1 -1 nodes
2k - 1 interior nodes
2k leaves
Complete Tree with n nodes
depth is log2n
Node count inequality 2k <= n < 2k+1
leads to k <= log2n < k+1
23
Counting Leaves
Algorithm (different from text)if tree is empty
return 0else if root has no children
return 1else
return leaves(TL) + leaves(TR)
24
Counting Leaves
template <typename T>int countLeaf (tnode<T> *t){ if (t == NULL) return 0; else if (t != NULL) { // if t is a leaf node (no children), it counts. if (t->left == NULL && t->right == NULL) return 1;
return (countLeaf(t->left + countLeaf(t->right); }}
25
Tree Depth (Height)
Tree height is 1 + MAX(depth(TL),depth(TR))
Algorithm
If tree is empty
return -1
else
return 1 + MAX(depth(TL),depth(TR))
26
Depth (Height)int depth (tnode<T> *t){ int depthLeft, depthRight, depthval;
if (t == NULL) depthval = -1; // depth of an empty tree is -1 else
{ depthLeft = depth(t->left); depthRight = depth(t->right); // depth is 1 + maximum subtree depth
depthval = 1 + (depthLeft > depthRight ? depthLeft : depthRight); }
return depthval;}
27
Deleting a treeAlgorithm
if tree not emptydelete both subtreesdelete root
template <typename T>void deleteTree(tnode<T> *t){ // postorder delete left and right subtrees of t // and then delete node t if (t != NULL) { deleteTree(t->left); deleteTree(t->right); delete t; }}
28
Binary Search Tree Definition
A binary search tree T is
(a) a binary tree, and
(b) each and every internal node R and its children (CL and CR), if they exist, have values such that (valueCL
< valueR <= valueCR)
29
Binary Search Trees
6 53 0
3 71 0
2 5
1 5
B in ary Search T ree 1
B in ary Search T ree 2
5 3
3 0
5 9
6 2
5 0
B in ary Search T ree 3
30
CLASS stree Constructors “d_stree.h”
stree();Create an empty search tree.
stree(T *first, T *last);Create a search tree with the elements from the
pointer range [first, last).
CLASS stree Opertions “d_stree.h”
void displayTree(int maxCharacters);Display the search tree. The maximum number of
characters needed to output a node value is maxCharacters.bool empty();
Return true if the tree is empty and false otherwise.
31
CLASS stree Opertions “d_stree.h”
int erase(const T& item);Search the tree and remove item, if it is present;
otherwise, take no action. Return the number of elements removed.
Postcondition: If item is located in the tree, the size of the tree decreases by 1.
void erase(iterator pos);Erase the item pointed to the iterator pos.
Precondition: The tree is not empty and pos points to an item in the tree. If the iterator is invalid, thefunction throws the referenceError exception.
Postcondition: The tree size decreases by 1.
32
CLASS stree Opertions “d_stree.h”
void erase(iterator first, iterator last);Remove all items in the iterator range [first, last).
Precondition: The tree is not empty. If empty, the function throws the underflowError exception.
Postcondition: The size of the tree decreases by the number of items in the range.
iterator find(const T& item);Search the tree by comparing item with the data
values in a path of nodes from the root of the tree. If a match occurs, return an iterator pointing to the matching value in the tree. If item is not in the tree, return the iterator value end().
33
CLASS stree Opertions “d_stree.h”
pair<iterator, bool> insert(const T& item);If item is not in the tree, insert it and return an iterator-bool pair where the iterator is the location of the new
element and the Boolean value is true. If item is already in the tree, return the pair where the iterator locates the existing item and the Boolean value is false.
Postcondition: The size of the tree is increased by 1 if item is not present in the tree.
int size();Return the number of elements in the tree.
34
What is a pair? Examples later.
The pair template data type is defined in the <utility> header file
It has two public members first and second The insert(item) function returns a pair containing an
iterator and a bool first is the iterator and it indicates the node in the Stree
containing the item second is a bool indicating whether the node was actually
added to the tree (true) or was already there (false) So, the pair gives a function a way to return two
values instead of one
35
STree Node Classtemplate <typename T>class stnode{ public: // public data simplifies building class functions T nodeValue; stnode<T> *left, *right, *parent;
// default constructor. data not initialized tnode() {}
// initialize the data members stnode (const T& item, stnode<T> *lptr = NULL, stnode<T> *rptr = NULL, stnode<T> *pptr = NULL) : nodeValue(item), left(lptr), right(rptr), parent(pptr)
{}};
36
Stree Iterators Perform INORDER traversals of tree Iterator and const_iterator are implemented as contained classes
within Stree class See “d_stree.h” and d_siter.h” Iterator is a two part object with pointer to root of Stree and to
current Stnode (see below)
private: stnode<T> *nodePtr; // current location in tree stree<T> *tree; // the tree
// used to construct an iterator return value // from an stnode pointer iterator (stnode<T> *p, stree<T> *t) : nodePtr(p), tree(t) {}
37
Locating value 37 in a BSTCurrent Node ActionRoot = 50 Compare item = 37 and 50 37 < 50, move to the left subtreeNode = 30 Compare item = 37 and 30 37 > 30, move to the right subtreeNode = 35 Compare item = 37 and 35 37 > 35, move to the right subtreeNode = 37 Compare item = 37 and 37. Item found.
50
62373210
60533525
5530
15
38
FindNode() function
template <typename T>stnode<T> *stree<T>::findNode(const T& item) const{
// cycle t through the tree starting with rootstnode<T> *t = root;// terminate on on empty subtreewhile(t != NULL && (item != t->nodeValue))
if (item < t->nodeValue)t = t->left;
else t = t->right;
// return pointer to node; NULL if not foundreturn t;
}
39
Stree find() function
template <typename T>stree<T>::iterator stree<T>::find(const T& item){
stnode<T> *curr;// search tree for itemcurr = findNode (item);// if item found, return iterator with value curr;// otherwise, return end()if (curr != NULL)
return iterator(curr, this);else
return end();}
40
Inserting into search tree All insertions are as LEAVES
Algorithm if tree is empty insert new node here
else if new value == node value return without inserting
else if new value < node value insert in left subtree
else if new value > node value insert in right subtree
41
Insert() functiontemplate <typename T>pair<stree<T>::iterator, bool> stree<T>::insert(const T& item){ stnode<T> *t = root, *parent = NULL, *newNode; while(t != NULL) { parent = t; if (item == t->nodeValue) // found a match return pair<iterator, bool> (iterator(t,this),false); else if (item < t->nodeValue) t = t->left; else t = t->right; }
newNode = getSTNode(item,NULL,NULL,parent);if (parent == NULL) // insert as root node
root = newNode;else if (item < parent->nodeValue) // insert as left child
parent->left = newNode; else // insert as right child
parent->right = newNode;treeSize++; return pair<iterator, bool> (iterator(newNode, this), true);
}
42
Insertion: 1st of 3 steps
The function begins at the root node and compares item 32 with the root value 25. Since 32 > 25, we traverse the right subtree and look at node 35.
2 5
4 01 2
3 52 0
p aren t
t
(a)St ep 1 : C o m p are 3 2 an d 2 5 .T rav ers e t h e righ t s u b t ree.
43
Insertion: 2nd of 3 steps
Considering 35 to be the root of its own subtree, we compare item 32 with 35 and traverse the left subtree of 35.
(b )St ep 2 : C o m p are 3 2 an d 3 5 .T rav ers e t h e left s u b t ree.
2 5
4 01 2
3 52 0
t
p aren t
44
Insertion: 3rd of 3 steps
Create a leaf node with data value 32, and insert the new node as the left child of node 35. newNode = getSTNode(item,NULL,NULL,parent);
parent->left = newNode;
(c)St ep 3 : In s ert 3 2 as left ch ildo f p aren t 3 5
2 5
4 01 2
3 52 0 p aren t
3 2
45
Deleting a node
Three cases (1) node that is a leaf
Just delete it
(2) node with single child Delete node and replace it in tree with its child
(3) node with two children Find inorder successor
This will be a leaf or a node with only a Right child Swap value of node and its inorder successor Delete successor node (now case 1 or 2)
46
Erase() functiontemplate <typename T>void stree<T>::erase(iterator pos){ // dNodePtr = pointer to node D that is deleted // pNodePtr = pointer to parent P of node D // rNodePtr = pointer to node R that replaces D stnode<T> *dNodePtr = pos.nodePtr, *pNodePtr, *rNodePtr;
if (treeSize == 0) throw underflowError("stree erase(): tree is empty");
if (dNodePtr == NULL) throw referenceError("stree erase(): invalid iterator");
// assign pNodePtr the address of P pNodePtr = dNodePtr->parent;
// now determine which case deletion we have // leaf node or node with single child (easy cases) // or node with 2 children (hard case) // continued ....
47
Erase() // If D has a NULL pointer, the // replacement node is the other child if (dNodePtr->left == NULL || dNodePtr->right == NULL) { if (dNodePtr->right == NULL) rNodePtr = dNodePtr->left; // replacement: left child else rNodePtr = dNodePtr->right; // replacement: right child
if (rNodePtr != NULL) // the parent of R is now the parent of D rNodePtr->parent = pNodePtr; } else // node has two children { // find inorder successor, right & then all the way left stnode<T> *pOfRNodePtr = dNodePtr; // parent of successor rNodePtr = dNodePtr->right; // step right while(rNodePtr->left != NULL) { pOfRNodePtr = rNodePtr; rNodePtr = rNodePtr->left; // step left ... }
48
Erase() if (pOfRNodePtr == dNodePtr) { // right child of deleted node is the replacement. rNodePtr->left = dNodePtr->left; rNodePtr->parent = pNodePtr; dNodePtr->left->parent = rNodePtr; } else { // we moved at least one node down a left branch // of the right child of D. link right subtree of R // as left subtree of parent of R pOfRNodePtr->left = rNodePtr->right; if (rNodePtr->right != NULL) rNodePtr->right->parent = pOfRNodePtr;
// link R to D’s children and parent rNodePtr->left = dNodePtr->left; rNodePtr->right = dNodePtr->right; rNodePtr->parent = pNodePtr; rNodePtr->left->parent = rNodePtr; rNodePtr->right->parent = rNodePtr; } }
49
Erase() // finally, connect R as correct child of parent node of D
// if deleting the root node. assign new root if (pNodePtr == NULL) root = rNodePtr; // else attach R as correct child of P else if (dNodePtr->nodeValue < pNodePtr->nodeValue) pNodePtr->left = rNodePtr; else pNodePtr->right = rNodePtr;
// delete the node from memory and decrement tree size delete dNodePtr; treeSize--;}
50
Removing an Item From a Binary Tree
1 0D
P
D e le te le a f n o d e 1 0 .p N o d e P tr-> le ft is d N o d e
N o re p la c e m e n t is n e c e s s a ry.p N o d e P tr-> le ft is N U L L
B efo re A ft er
4 0
3 5
6 53 0
5 0
3 32 6
2 5
3 42 9
2 8
P
4 0
3 5
6 53 0
5 0
3 32 6
2 5
3 42 9
2 8
51
Removing an Item From a Binary Tree
D
P
D e le te n o de 3 5 with o n ly a le f t ch ild: No de R is th e le f t ch ild.
B e fo re
R
40
35
6530
50
3310 26
25
3429
28
P
A tta ch n o de R to th e pa re n t .
A fte r
R
40
33
6530
50
10 26
25
34
29
28
52
Removing an Item From a Binary Tree
P
D e le te n o d e 2 6 w ith o n ly a rig h t c h ild : N o d e R is th e rig h t c h ild .
P
A tta c h n o d e R to th e p a re n t.
B efo re A ft er
R
R
4 0
3 5
6 53 0
5 0
3 31 0 2 6
2 5
3 42 9
2 8
4 0
3 5
6 53 0
5 0
3 31 0 2 9
2 5
3 42 8
D
53
Removing an Item From a Binary Tree
4 0
3 5
6 53 0
D e le te n o d e 3 0 w ith tw o c h ild re n .
5 0
3 31 0 2 6
2 5
3 42 9
2 8
4 0
3 5
6 5
O rp h a n e d s u b tre e s .
5 0
3 31 0
2 5
3 4
2 6
2 9
2 8
54
Removing an Item From a Binary Tree
D
R
d N o d eP t r
rN o d eP t rp O fR N o d eP t r
Pp N o d eP t r 4 0
3 5
6 53 0
5 0
3 31 0 2 6
2 5
3 42 9
2 8
P
R
4 0
3 5
6 53 0
5 0
3 41 0
2 6
3 3
2 9
2 8
p N o d eP t r
DR
rN o d eP t r
p O fR N o d eP t r
B efo re u n lin k in g R A ft er u n lin k in g R
55
Removing an Item From a Binary Tree
P
4 0
3 5
6 53 3
5 0
3 41 0
2 6
2 9
2 8
p N o d eP t r
RrN o d eP t r
P
4 0
3 5
6 53 0
5 0
3 41 0
2 6
2 9
2 8
p N o d eP t r
D3 3R
rN o d eP t r
B efo re rep lacin g D b y R A ft er rep lacin g D b y R
56
Simple Application -- Removing Duplicates Since a binary search tree does not insert
duplicates, a vector can be purged of duplicates by …
For each element in vector Insert element in binary search tree
Clear vector For each element in binary search tree
Append element to vector Clear binary search tree If the search tree is traversed “inorder” this results in
a sort of the vector as well
57
Using Binary Search Trees Application: Removing Duplicates
7
52
37 3 2 5 3 2 9 3 2 3 5 7 9
9v v
58
Stree begin() and end()template <typename T>stree<T>::iterator stree<T>::begin(){ stnode<T> *curr = root; // if the tree is not empty, the first node // inorder is the farthest node left from root if (curr != NULL) while (curr->left != NULL) curr = curr->left;
// build return value using private constructorreturn iterator(curr, this);
}
template <typename T>stree<T>::iterator stree<T>::end(){
// end indicated by iterator with NULL stnode pointerreturn iterator(NULL, this);
}
59
Stree iterator preincrement operator++iterator& operator++ () // preincrement. move forward inorder{ stnode<T> *p; if (nodePtr == NULL) // ++ from end() { nodePtr = tree->root; // start at root if (nodePtr == NULL) throw underflowError("stree iter op++ (): t empty"); // move to smallest value in tree, 1st node inorder while (nodePtr->left != NULL) nodePtr = nodePtr->left; } else if (nodePtr->right != NULL) { // find successor { nodePtr = nodePtr->right; // step right while (nodePtr->left != NULL) nodePtr = nodePtr->left; // go all the way left } else // move up the tree, looking for a parent having { // *nodePtr is left child p = nodePtr->parent; while (p != NULL && nodePtr == p->right) { nodePtr = p; p = p->parent; } nodePtr = p; // now, either p is NULL or *p is the successor } return *this;}