No Slide Titlegercal/cs340/slides/review/binary-yolum.pdf · 12 Terminology A node that has...
Transcript of No Slide Titlegercal/cs340/slides/review/binary-yolum.pdf · 12 Terminology A node that has...
1
5 Linked Structures
Based on Levent Akın’s CmpE160
Lecture Slides
3
Binary Trees
2
Owner
Jake
Manager Chef
Brad Carol
Waitress Waiter Cook Helper Joyce Chris Max Len
Jake‟s Pizza Shop
3
Definition of Tree
A tree is a finite set of one or more nodes such that:
There is a specially designated node called the root.
The remaining nodes are partitioned into n>=0 disjoint sets T1, ..., Tn, where each of these sets is a tree.
We call T1, ..., Tn the subtrees of the root.
Definition
4
Owner
Jake
Manager Chef
Brad Carol
Waitress Waiter Cook Helper Joyce Chris Max Len
ROOT NODE
A Tree Has a Root Node
5
Owner
Jake
Manager Chef
Brad Carol
Waitress Waiter Cook Helper Joyce Chris Max Len
LEAF NODES
Leaf Nodes have No Children
6
Owner
Jake
Manager Chef
Brad Carol
Waitress Waiter Cook Helper Joyce Chris Max Len
LEVEL 0
A Tree Has Leaves
7
Owner
Jake
Manager Chef
Brad Carol
Waitress Waiter Cook Helper Joyce Chris Max Len
LEVEL 1
Level One
8
Owner
Jake
Manager Chef
Brad Carol
Waitress Waiter Cook Helper Joyce Chris Max Len
LEVEL 2
Level Two
9
Owner
Jake
Manager Chef
Brad Carol
Waitress Waiter Cook Helper Joyce Chris Max Len
LEFT SUBTREE OF ROOT NODE
A Subtree
10
Owner
Jake
Manager Chef
Brad Carol
Waitress Waiter Cook Helper Joyce Chris Max Len
RIGHT SUBTREE
OF ROOT NODE
Another Subtree
11
Terminology
The degree of a node is the number of
subtrees of the node
The node with degree 0 is a leaf or
terminal node. All other nodes are
nonterminals.
The degree of a tree is the maximum
degree of the nodes of a tree.
12
Terminology
A node that has subtrees is the parent of the roots of the subtrees.
The roots of these subtrees are the children of the node.
Children of the same parent are siblings.
The ancestors of a node are all the nodes along the path from the root to the node
The height or depth of a tree is the maximum level of any node in the tree.
13
Level and Depth
K L
E F
B
G
C
M
H I J
D
A
Level
1
2
3
4
3
2 1 3
2 0 0 1 0 0
0 0 0
1
2 2 2
3 3 3 3 3 3
4 4 4
Sample Tree
Tree Representations
For a tree of degree k (also called a k-ary
tree), we could define a node structure that
contains a data field plus k link fields.
Advantage: uniform node structure (can
insert/delete nodes without having to change node
structure)
Disadvantage: many null link fields
data link 1 link 2 ... link k
Tree Representations
(continued)
In general, for a tree of degree k with n nodes, we
know that the total number of link fields in the tree
is kn and that exactly n-1 of them are not null.
Therefore the number of null links is
kn - (n-1) = (k-1)n + 1.
degree proportion of links that are null 2 (n+1)/2n, or about 1/2 3 (2n+1)/3n, or about 2/3 4 (3n+1)/4n, or about 3/4
16
Percentage of Null links
Tree Representations
(continued)
Clearly, to reduce the proportion of null
links, we need to reduce the degree of
the tree.
An alternative representation for a tree
of degree k:
Use a left child-right sibling representation.
Each node has two pointers, one to its left
child and one to its right sibling.
18
Left Child - Right Sibling link structure
A
B C D
E F G H I J
K L M
data
left child right sibling
19
The actual tree represented by it
A
B C D
E F G H I J
K L M
20
A binary tree is a structure in which:
Each node can have at most two children, and in which a unique path exists from the root to every other node.
The two children of a node are called the left child and the right child, if they exist.
Binary Tree
21
A Binary Tree
Q
V
T
K S
A E
L
22
How many leaf nodes?
Q
V
T
K S
A E
L
23
How many descendants of Q?
Q
V
T
K S
A E
L
24
How many ancestors of K?
Q
V
T
K S
A E
L
25
Implementing a Binary Tree with
Pointers and Dynamic Data
Q
V
T
K S
A E
L
26
Node Terminology for a Tree Node
27
A
B
A
B
A
B C
G E
I
D
H
F
Complete Binary Tree
Skewed Binary Tree
E
C
D
1
2
3
4 5
Samples of Binary Trees
28
The maximum number of nodes on level i of
a binary tree is 2i-1, i≥1.
The maximum number of nodes in a binary
tree of depth k is 2k-1, k ≥ 1.
Prove by induction.
2 2 11
1
i
i
kk
Maximum Number of Nodes in BT
29
For any nonempty binary tree, T, if n0 is the
number of leaf nodes and n2 the number of
nodes of degree 2, then n0=n2+1
proof:
Let n and B denote the total number of
nodes & branches in T.
Let n0, n1, n2 represent the nodes with no
children, single child, and two children
respectively.
n= n0+n1+n2, B+1=n, B=n1+2n2 ==> n1+2n2+1= n, n1+2n2+1= n0+n1+n2 ==> n0=n2+1
Relations between Number of
Leaf Nodes and Nodes of Degree 2
30
Definitions
Full Binary Tree: A binary tree in which
all of the leaves are on the same level
and every nonleaf node has two
children
31
Definitions (cont.)
Complete Binary Tree: A binary tree
that is either full or full through the next-
to-last level, with the leaves on the last
level as far to the left as possible
32
Examples of Different Types of
Binary Trees
33
A full binary tree of depth k is a binary tree of
depth k having 2 -1 nodes, k ≥ 0.
A binary tree with n nodes and depth k is
complete iff its nodes correspond to the nodes
numbered from 1 to n in the full binary tree of
depth k.
k
A
B C
G E
I
D
H
F
A
B C
G E
K
D
J
F
I H O N M L
Full binary tree of depth 4 Complete binary tree
Full BT VS Complete BT
34
A Binary Tree and Its
Array Representation
35
With Array Representation
For any node tree.nodes[index]
its left child is in tree.nodes[index*2
+ 1]
right child is in tree.nodes[index*2 +
2]
its parent is in tree.nodes[(index –
1)/2].
36
Sequential representation
A
B
--
C
--
--
--
D
--
.
E
[0]
[1]
[2]
[3]
[4]
[5]
[6]
[7]
[8]
.
[15]
[0]
[1]
[2]
[3]
[4]
[5]
[6]
[7]
[8]
A
B
C
D
E
F
G
H
I
A
B
E
C
D
A
B C
G E
I
D
H
F
(1) space waste
(2) insertion/deletion
problem
37
typedef struct node *treePointer;
typedef struct node {
ItemType data;
treePointer leftChild;
treePointer rightChild;
};
data leftChild rightChild
data
leftChild rightChild
Linked Representation
38
Let L, V, and R stand for moving left, visiting
the node, and moving right.
There are six possible combinations of
traversal
LVR, LRV, VLR, VRL, RVL, RLV
Adopt convention that we traverse left
before right, only 3 traversals remain
LVR, LRV, VLR
inorder, postorder, preorder
Binary Tree Traversals
39
+
*
A
*
/
E
D
C
B
Arithmetic Expression Using BT
40
void inorder(treePointer ptr)
// inorder tree traversal
{
if (ptr!=NULL) {
inorder(ptr->leftChild);
visit(ptr->data);
inorder(ptr->rightChild);
}
}
A / B * C * D + E
Inorder Traversal (recursive version)
41
void preorder(treePointer ptr)
// preorder tree traversal
{
if (ptr!=NULL) {
visit(ptr->data);
preorder(ptr->leftChild);
preorder(ptr->rightChild);
}
}
+ * * / A B C D E
Preorder Traversal (recursive version)
42
void postorder(treePointer ptr)
// postorder tree traversal
{
if (ptr!=NULL) {
postorder(ptr->leftChild);
postorder(ptr->rightChild);
visit(ptr->data);
}
}
A B / C * D * E +
Postorder Traversal (recursive version)
43
O(n)
Iterative Inorder Traversal (using stack)
void iter_inorder(treePointer node)
{
StackType<treePointer> NodeStack;
bool completed=false;
while (!completed) {
while(node!=NULL){
NodeStack.push(node); // add to stack
node=node->leftChild
}
NodeStack.pop(node); // delete from stack
if (node!=NULL){
cout << node->data;
node = node->rightChild;
}
else completed=true;
}
}
44
Call of inorder Value in root Action Call of inorder Value in root Action
1 + 11 C
2 * 12 NULL
3 * 11 C printf
4 / 13 NULL
5 A 2 * printf
6 NULL 14 D
5 A printf 15 NULL
7 NULL 14 D printf
4 / printf 16 NULL
8 B 1 + printf
9 NULL 17 E
8 B printf 18 NULL
10 NULL 17 E printf
3 * printf 19 NULL
Trace Operations of Inorder Traversal
45
Level Order Traversal (using queue)
void level_order(treePointer ptr)
/* level order tree traversal */
{
QueueType<treePointer> NodeQueue;
if (ptr!=NULL) {
NodeQueue.enqueue(ptr);
for (;;) {
NodeQueue.dequeue(ptr);
46
if (ptr!=NULL) {
cout << ptr->data;
if (ptr->leftChild)
NodeQueue.enqueue(ptr->leftChild);
if (ptr->rightChild!=NULL)
NodeQueue.enqueue(ptr->rightChild);
}
else break;
}
}
+ * E * D / C A B
47
+
*
A
*
/
E
D
C
B
inorder traversal
A / B * C * D + E
infix expression
preorder traversal
+ * * / A B C D E
prefix expression
postorder traversal
A B / C * D * E +
postfix expression
level order traversal
+ * E * D / C A B
Arithmetic Expression Using BT
48
A special kind of binary tree in which:
1. Each node contains a distinct data value,
2. The key values in the tree can be compared using
“greater than” and “less than”, and
3. The key value of each node in the tree is
less than every key value in its right subtree, and
greater than every key value in its left subtree.
A Binary Search Tree (BST) is . . .
49
Depends on its key values and their order of insertion.
Insert the elements „J‟ „E‟ „F‟ „T‟ „A‟ in that order.
The first value to be inserted is put into the root node.
Shape of a binary search tree . . .
„J‟
50
Thereafter, each value to be inserted begins by
comparing itself to the value in the root node,
moving left it is less, or moving right if it is greater.
This continues at each level until it can be inserted
as a new leaf.
Inserting „E‟ into the BST
„J‟
„E‟
51
Begin by comparing „F‟ to the value in the root node,
moving left it is less, or moving right if it is greater.
This continues until it can be inserted as a leaf.
Inserting „F‟ into the BST
„J‟
„E‟
„F‟
52
Begin by comparing „T‟ to the value in the root node,
moving left it is less, or moving right if it is greater.
This continues until it can be inserted as a leaf.
Inserting „T‟ into the BST
„J‟
„E‟
„F‟
„T‟
53
Begin by comparing „A‟ to the value in the root node,
moving left it is less, or moving right if it is greater.
This continues until it can be inserted as a leaf.
Inserting „A‟ into the BST
„J‟
„E‟
„F‟
„T‟
„A‟
54
is obtained by inserting
the elements „A‟ „E‟ „F‟ „J‟ „T‟ in that order?
What binary search tree . . .
„A‟
55
obtained by inserting
the elements „A‟ „E‟ „F‟ „J‟ „T‟ in that order.
Binary search tree . . .
„A‟
„E‟
„F‟
„J‟
„T‟
56
Another binary search tree
Add nodes containing these values in this order:
„D‟ „B‟ „L‟ „Q‟ „S‟ „V‟ „Z‟
„J‟
„E‟
„A‟ „H‟
„T‟
„M‟
„K‟ „P‟
57
Is „F‟ in the binary search tree?
„J‟
„E‟
„A‟ „H‟
„T‟
„M‟
„K‟
„V‟
„P‟ „Z‟ „D‟
„Q‟ „L‟ „B‟
„S‟
58
Class TreeType
// Assumptions: Relational operators overloaded
class TreeType
{
public:
// Constructor, destructor, copy constructor
...
// Overloads assignment
...
// Observer functions
...
// Transformer functions
...
// Iterator pair
...
void Print(std::ofstream& outFile) const;
private:
TreeNode* root;
};
59
bool TreeType::IsFull() const
{
NodeType* location;
try
{
location = new NodeType;
delete location;
return false;
}
catch(std::bad_alloc exception)
{
return true;
}
}
bool TreeType::IsEmpty() const
{
return root == NULL;
}
60 60
Tree Recursion
CountNodes Version 1
if (Left(tree) is NULL) AND (Right(tree) is NULL)
return 1
else
return CountNodes(Left(tree)) +
CountNodes(Right(tree)) + 1
What happens when Left(tree) is NULL?
61 61
Tree Recursion
CountNodes Version 2
if (Left(tree) is NULL) AND (Right(tree) is NULL)
return 1
else if Left(tree) is NULL
return CountNodes(Right(tree)) + 1
else if Right(tree) is NULL
return CountNodes(Left(tree)) + 1
else return CountNodes(Left(tree)) + CountNodes(Right(tree)) + 1
What happens when the initial tree is NULL?
62 62
Tree Recursion
CountNodes Version 3
if tree is NULL
return 0
else if (Left(tree) is NULL) AND (Right(tree) is NULL)
return 1
else if Left(tree) is NULL
return CountNodes(Right(tree)) + 1
else if Right(tree) is NULL
return CountNodes(Left(tree)) + 1
else return CountNodes(Left(tree)) +
CountNodes(Right(tree)) + 1
Can we simplify this algorithm?
63
Tree Recursion
CountNodes Version 4
if tree is NULL
return 0
else
return CountNodes(Left(tree)) +
CountNodes(Right(tree)) + 1
Is that all there is?
64
// Implementation of Final Version
int CountNodes(TreeNode* tree); // Pototype
int TreeType::LengthIs() const
// Class member function
{
return CountNodes(root);
}
int CountNodes(TreeNode* tree)
// Recursive function that counts the nodes
{
if (tree == NULL)
return 0;
else
return CountNodes(tree->left) +
CountNodes(tree->right) + 1;
}
65
Retrieval Operation
66
Retrieval Operation
void TreeType::RetrieveItem(ItemType& item, bool& found)
{
Retrieve(root, item, found);
}
void Retrieve(TreeNode* tree,
ItemType& item, bool& found)
{
if (tree == NULL)
found = false;
else if (item < tree->info)
Retrieve(tree->left, item, found);
67
Retrieval Operation, cont.
else if (item > tree->info)
Retrieve(tree->right, item, found);
else
{
item = tree->info;
found = true;
}
}
68
The Insert Operation
A new node is always inserted into its
appropriate position in the tree as a leaf.
69
Insertions into a Binary Search Tree
70
The recursive InsertItem operation
71
The tree parameter
is a pointer within the tree
72
Recursive Insert
void Insert(TreeNode*& tree, ItemType item)
{
if (tree == NULL)
{// Insertion place found.
tree = new TreeNode;
tree->right = NULL;
tree->left = NULL;
tree->info = item;
}
else if (item < tree->info)
Insert(tree->left, item);
else
Insert(tree->right, item);
}
73
Deleting a Leaf Node
74
Deleting a Node with One Child
75
Deleting a Node with Two Children
76
DeleteNode Algorithm
if (Left(tree) is NULL) AND (Right(tree) is NULL)
Set tree to NULL
else if Left(tree) is NULL
Set tree to Right(tree)
else if Right(tree) is NULL
Set tree to Left(tree)
else
Find predecessor
Set Info(tree) to Info(predecessor)
Delete predecessor
77
Code for DeleteNode
void DeleteNode(TreeNode*& tree)
{
ItemType data;
TreeNode* tempPtr;
tempPtr = tree;
if (tree->left == NULL) {
tree = tree->right;
delete tempPtr; }
else if (tree->right == NULL){
tree = tree->left;
delete tempPtr;}
else
{
GetPredecessor(tree->left, data);
tree->info = data;
Delete(tree->left, data);
}
}
78
Definition of Recursive Delete
Definition: Removes item from tree
Size: The number of nodes in the path from the
root to the node to be deleted.
Base Case: If item's key matches key in Info(tree),
delete node pointed to by tree.
General Case: If item < Info(tree),
Delete(Left(tree), item);
else
Delete(Right(tree), item).
79
Code for Recursive Delete
void Delete(TreeNode*& tree, ItemType item)
{
if (item < tree->info)
Delete(tree->left, item);
else if (item > tree->info)
Delete(tree->right, item);
else
DeleteNode(tree); // Node found
}
80
Code for GetPredecessor
void GetPredecessor(TreeNode* tree,
ItemType& data)
{
while (tree->right != NULL)
tree = tree->right;
data = tree->info;
}
Why is the code not recursive?
81
Printing all the Nodes in Order
82
Function Print
Function Print
Definition: Prints the items in the binary search
tree in order from smallest to largest.
Size: The number of nodes in the tree whose
root is tree
Base Case: If tree = NULL, do nothing.
General Case: Traverse the left subtree in order.
Then print Info(tree).
Then traverse the right subtree in order.
83
Code for Recursive InOrder Print
void PrintTree(TreeNode* tree,
std::ofstream& outFile)
{
if (tree != NULL)
{
PrintTree(tree->left, outFile);
outFile << tree->info;
PrintTree(tree->right, outFile);
}
}
Is that all there is?
84
Destructor
void Destroy(TreeNode*& tree);
TreeType::~TreeType()
{
Destroy(root);
}
void Destroy(TreeNode*& tree)
{
if (tree != NULL)
{
Destroy(tree->left);
Destroy(tree->right);
delete tree;
} }
85
Algorithm for Copying a Tree
if (originalTree is NULL)
Set copy to NULL
else
Set Info(copy) to Info(originalTree)
Set Left(copy) to Left(originalTree)
Set Right(copy) to Right(originalTree)
86
Code for CopyTree
void CopyTree(TreeNode*& copy,
const TreeNode* originalTree)
{
if (originalTree == NULL)
copy = NULL;
else
{
copy = new TreeNode;
copy->info = originalTree->info;
CopyTree(copy->left, originalTree->left);
CopyTree(copy->right, originalTree->right);
}
}
87
Inorder(tree)
if tree is not NULL
Inorder(Left(tree))
Visit Info(tree)
Inorder(Right(tree))
To print in alphabetical order
88
Postorder(tree)
if tree is not NULL
Postorder(Left(tree))
Postorder(Right(tree))
Visit Info(tree)
Visits leaves first
(good for deletion)
89
Preorder(tree)
if tree is not NULL
Visit Info(tree)
Preorder(Left(tree))
Preorder(Right(tree))
Useful with binary trees
(not binary search trees)
90
Three Tree Traversals
91
Our Iteration Approach
The client program passes the ResetTree and
GetNextItem functions a parameter indicating
which of the three traversals to use
ResetTree generates a queues of node contents in the indicated order
GetNextItem processes the node contents from the appropriate queue: inQue, preQue, postQue.
92
Code for ResetTree
void TreeType::ResetTree(OrderType order)
// Calls function to create a queue of the tree
// elements in the desired order.
{
switch (order)
{
case PRE_ORDER : PreOrder(root, preQue);
break;
case IN_ORDER : InOrder(root, inQue);
break;
case POST_ORDER: PostOrder(root, postQue);
break;
}
}
93
void TreeType::GetNextItem(ItemType& item,
OrderType order,bool& finished)
{
finished = false;
switch (order)
{
case PRE_ORDER : preQue.Dequeue(item);
if (preQue.IsEmpty())
finished = true;
break;
case IN_ORDER : inQue.Dequeue(item);
if (inQue.IsEmpty())
finished = true;
break;
case POST_ORDER: postQue.Dequeue(item);
if (postQue.IsEmpty())
finished = true;
break;
}
}
Code for GetNextItem
94
Iterative Versions
FindNode
Set nodePtr to tree
Set parentPtr to NULL
Set found to false
while more elements to search AND NOT found
if item < Info(nodePtr)
Set parentPtr to nodePtr
Set nodePtr to Left(nodePtr)
else if item > Info(nodePtr)
Set parentPtr to nodePtr
Set nodePtr to Right(nodePtr)
else
Set found to true
95
void FindNode(TreeNode* tree, ItemType item,
TreeNode*& nodePtr, TreeNode*& parentPtr)
{
nodePtr = tree;
parentPtr = NULL;
bool found = false;
while (nodePtr != NULL && !found)
{ if (item < nodePtr->info)
{
parentPtr = nodePtr;
nodePtr = nodePtr->left;
}
else if (item > nodePtr->info)
{
parentPtr = nodePtr;
nodePtr = nodePtr->right;
}
else found = true;
}
}
Code for
FindNode
96
InsertItem
Create a node to contain the new item.
Find the insertion place.
Attach new node.
Find the insertion place
FindNode(tree, item, nodePtr, parentPtr);
97
Using function FindNode to find
the insertion point
98
Using function FindNode to find
the insertion point
99
Using function FindNode to find
the insertion point
100
Using function FindNode to find
the insertion point
101
Using function FindNode to find
the insertion point
102
AttachNewNode
if item < Info(parentPtr)
Set Left(parentPtr) to newNode
else
Set Right(parentPtr) to newNode
103
AttachNewNode(revised)
if parentPtr equals NULL
Set tree to newNode
else if item < Info(parentPtr)
Set Left(parentPtr) to newNode
else
Set Right(parentPtr) to newNode
104
Code for InsertItem
void TreeType::InsertItem(ItemType item)
{
TreeNode* newNode;
TreeNode* nodePtr;
TreeNode* parentPtr;
newNode = new TreeNode;
newNode->info = item;
newNode->left = NULL;
newNode->right = NULL;
FindNode(root, item, nodePtr, parentPtr);
if (parentPtr == NULL)
root = newNode;
else if (item < parentPtr->info)
parentPtr->left = newNode;
else parentPtr->right = newNode;
}
105
Code for DeleteItem
void TreeType::DeleteItem(ItemType item)
{
TreeNode* nodePtr;
TreeNode* parentPtr;
FindNode(root, item, nodePtr, parentPtr);
if (nodePtr == root)
DeleteNode(root);
else
if (parentPtr->left == nodePtr)
DeleteNode(parentPtr->left);
else DeleteNode(parentPtr->right);
}
106
PointersnodePtr and parentPtr
Are External to the Tree
107
Pointer parentPtr is External to the Tree, but
parentPtr-> left is an Actual Pointer in the Tree
108
A Binary Search Tree Stored in an
Array with Dummy Values