Lec 12 Trees BST
Transcript of Lec 12 Trees BST
-
8/3/2019 Lec 12 Trees BST
1/17
Binary Search Trees
-
8/3/2019 Lec 12 Trees BST
2/17
Searching the Tree
The IntBinaryTree class has a public member function called
searchNode, that returns true if a value is found in the tree, orfalse otherwise.
The functionstarts at the root node, and traverses the tree, until it
finds the search value, orruns out
of nodes.bool IntBinaryTree::searchNode(int num){
TreeNode *nodePtr = root;
while (nodePtr)
{
if (nodePtr->value == num)return true;
else if (num < nodePtr->value)
nodePtr = nodePtr->left;
else
nodePtr = nodePtr->right;
}
return false;}
-
8/3/2019 Lec 12 Trees BST
3/17
Searching50
25
1812
90
10065
7060
Searching for 80 in BST Start from root node
80>50, so will move to node right
to root, which has data 90
8075, so will move right
from this node which has
data 80
And our search is complete
At this point
50
90
75
80
Found, Search complete
-
8/3/2019 Lec 12 Trees BST
4/17
Program
// This program builds a binary tree with 5 nodes.// The SearchNode function determines if the
// value 3 is in the tree.
#include
#include "IntBinaryTree.h
void main(void)
{
IntBinaryTree tree;
cout
-
8/3/2019 Lec 12 Trees BST
5/17
if (tree.searchNode(3))
cout
-
8/3/2019 Lec 12 Trees BST
6/17
How to delete a node if it has child nodes?
We want to delete the node, but preserve the sub-trees, that thenode links to.
There are 2 possible situations to be faced when deleting a non leaf
node -
1) The node has one child.
2) The node has two children.
-
8/3/2019 Lec 12 Trees BST
7/17
The problem is not as easily solved if the node has two children.
-
8/3/2019 Lec 12 Trees BST
8/17
We cannot attach both of the nodes subtrees to its parent.
One solution is to -
a) find a position in the right subtree to attach the left subtree.
b) attach the nodes right subtree to the parent
-
8/3/2019 Lec 12 Trees BST
9/17
Now the code - to delete a node from the IntBinaryTree, call the
public memberremove. The argument passed to the function is the
value of the node you want to delete.
-
8/3/2019 Lec 12 Trees BST
10/17
void IntBinaryTree::remove(int num)
{
deleteNode(num, root);}
The remove member function calls the deleteNode member
function. It passes the value of the node to delete, and the root
pointer.
The deleteNode member function is shown below -
-
8/3/2019 Lec 12 Trees BST
11/17
void IntBinaryTree::deleteNode(int num, TreeNode *&nodePtr)
{
if (num < nodePtr->value)
deleteNode(num, nodePtr->left);
else if (num > nodePtr->value)
deleteNode(num, nodePtr->right);
else
makeDeletion(nodePtr);
}
Notice the declaration of the nodePtrparameter:
TreeNode *&nodePtr;
nodePtr is not simply a pointer to a TreeNode structure, but a reference to a
pointer to a TreeNode structure. Any action performed on nodePtr is actuallyperformed on the argument passed into nodePtr
The reason for doing this is explained shortly.
The deleteNode function uses an if/else statement.
-
8/3/2019 Lec 12 Trees BST
12/17
if(num < nodePtr->value)
deleteNode(num, nodePtr->left);
The above statement compares the parameter num with the value
member of the node that nodePtr point to.
If num is less, the value being searched for will appear somewhere
in the nodePtrs left subtree (if it appears at all).
So recall the deleteNode function recursively, with num as the first
argument, and nodePtr->left as the second argument.
If num is not less than nodePtr->value, the the following else if
statement is executed.
else if(num > nodePtr->value)
deleteNode(num, nodeP
tr->right);
-
8/3/2019 Lec 12 Trees BST
13/17
If num is greater than nodePtr->value, then the value being searched
for will appear somewhere in nodePtrs right subtree (if it appears
in the tree at all).
If num is equal to nodePtr->value, then neither of the if statements
above will find a true condition.
So, nodePtr points to the node to be deleted, and the trailing else will
be executed.
else
makeDeletion(nodePtr);
The makeDeletion function actually deletes the node from the tree
and reattaches the deleted nodes sub trees.
-
8/3/2019 Lec 12 Trees BST
14/17
It must have access to the actualpointer in the tree to the node that
is being deleted (not just a copy of the pointer).
This is why the nodePtrparameter in the deleteNode function is a
reference. It must pass to makeDeletion, the actual pointer, to the
node to be deleted.
void IntBinaryTree::makeDeletion(TreeNode *&nodePtr)
{
TreeNode *tempNodePtr; // Temporary pointer, used in
// reattaching the left subtree.
if (nodePtr == NULL)
cout right == NULL)
{
tempNodePtr = nodePtr;
nodePtr = nodePtr->left; // Reattach the left child
delete tempNodePtr;
}
-
8/3/2019 Lec 12 Trees BST
15/17
else if (nodePtr->left == NULL)
{
tempNodePtr = nodePtr;
nodePtr = nodePtr->right; // Reattach the right child
delete tempNodePtr;
}
// If the node has two children.
else
{
// Move one node the right.
tempNodePtr = nodePtr->right;// Go to the end left node.
while (tempNodePtr->left)
tempNodePtr = tempNodePtr->left;
// Reattach the left subtree.
tempNodePtr->left = nodePtr->left;
tempNodePtr = nodePtr;
// Reattach the right subtree.nodePtr = nodePtr->right;
delete tempNodePtr;
}
}
-
8/3/2019 Lec 12 Trees BST
16/17
Program
// This program builds a binary tree with 5 nodes.
// The DeleteNode function is used to remove two
// of them.
#include
#include "IntBinaryTree.h
void main(void)
{IntBinaryTree tree;
cout
-
8/3/2019 Lec 12 Trees BST
17/17
cout