lec 12 trees bst

8/3/2019 Lec 12 Trees BST

1/17

Binary Search Trees


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;}


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


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


5/17

if (tree.searchNode(3))

cout


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.


7/17

The problem is not as easily solved if the node has two children.


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


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.


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 -


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.


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);


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.


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;

}


15/17

else if (nodePtr->left == NULL)

{


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;


// Reattach the right subtree.nodePtr = nodePtr->right;

delete tempNodePtr;

}

}


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


17/17

cout

lec 12 trees bst

Documents