Scribd
Upload
4 views

DSA Lec 8

The lecture covers insertion and deletion algorithms for Binary Search Trees (BST). It details how to find the location for insertion, handle node deletions for both leaf and internal nodes, and the implications of deletions on tree balance. Additionally, it provides specific algorithms for deleting nodes with different child configurations.

Uploaded by

Asmad Shoaib
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
4 views

DSA Lec 8

The lecture covers insertion and deletion algorithms for Binary Search Trees (BST). It details how to find the location for insertion, handle node deletions for both leaf and internal nodes, and the implications of deletions on tree balance. Additionally, it provides specific algorithms for deleting nodes with different child configurations.

Uploaded by

Asmad Shoaib
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 16

Lecture 23

Trees
Course Instructor
Engr. Anum Raza
Lecture Outline
 Insertion in BST
 Deletion in BST
Algorithm1 for Finding Loc for Insertion
 (This algorithm finds location Loc of Item and the location Par
of Parent of Item)

 1) If Root= NULL then Loc=NULL, Par=NULL and Exit


 2) If Item= Data[Root], Loc=Root and Par=NULL and Exit
 3) If Item< Data[Root], then Save=Root and Ptr=Left[Root]
 Else Save=Root and Ptr=Right[Root]
 4) Repeat while (Ptr ≠ NULL)
 If Item=Data[Ptr], Loc=Ptr and Par= Save and Exit
 Else if Item < Data[Ptr], Save= Ptr, and Ptr=Left [Ptr]
 Else Save=Ptr and Ptr=Right[Ptr]
 5) [Search Unsuccessful] Set Loc=NULL and Par=Save and Exit
Algorithm 2 for Insertion
 (This algorithm finds location Loc of Item or adds Item as new
Node in Tree at Location Loc)

 1) If Loc=NULL then Insertion is not possible


 2) If Avail=NULL then Overflow and Return
 3) Set New=Avail and Avail=Left[Avail]
 4) Data[New]=Item 20
 Left[New]=NULL
 Right[New]=NULL 15 44
 5) If Par ≠ NULL
 If Item< Data[Par]
 Left[Par]= New 22 50
 Else
 Right[Par]=New
 Else 23
 Root=New
 6) Exit
Deleting a Node
To delete a leaf node is easy -
a) Find its parent
b) Set the child pointer that links to it to NULL
c) Free the node’s memory
Example Deletion (Leaf)
 Delete ( 25 )
10 10
10 < 25, right
5 30 30 > 25, left 5 30
25 = 25, delete
2 25 45 2 45
How to delete a node if it has child nodes?

We want to delete the node, but preserve the sub-trees, that the
node 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.
Example: Node to be removed has
one child..
 Remove 18
The problem is not as easily solved if the node has two children.
We cannot attach both of the node’s subtrees to its parent.

One solution is to -
a) find a position in the right subtree to attach the left subtree.
b) attach the node’s right subtree to the parent
Binary Search Tree – Deletion
 Algorithm
1. Perform search for value X
2. If X is a leaf, delete X
3. Else // must delete internal node
a) Replace with largest value Y on left subtree
OR smallest value Z on right subtree
b) Delete replacement value (Y or Z) from subtree
Observation
 Deletions may unbalance tree
Example Deletion (Internal Node)
 Delete ( 10 )

10 5 5

5 30 5 30 2 30

2 25 45 2 25 45 2 25 45

Replacing 10 Replacing 5 Deleting leaf


with largest with largest
value in left value in left
subtree subtree
Example Deletion (Internal Node)
 Delete ( 10 )

10 25 25

5 30 5 30 5 30

2 25 45 2 25 45 2 45

Replacing 10 Deleting leaf Resulting tree


with smallest
value in right
subtree
Now the code - to delete a node from the IntBinaryTree, call the
public member remove. The argument passed to the function is the
value of the node you want to delete.
Deletion Algorithm for less than
two children
 (This procedure deletes node N at location Loc where N does not
have two children. The pointer Par gives location of parent of N.
the pointer Child gives the location of the only child of N)

 1) If Left[Loc]=NULL and Right[Loc]=NULL


 Then Child=NULL
 Else If Left[Loc] ≠ NULL, Child=Left[Loc]
 Else 50
 Child=Right[Loc]
 2) If Par ≠ NULL 30 44
 If Loc=Left[Par]
 Left[Par]=Child
 Else 20 35
 Right[Par]=Child Loc=6, Par=5
 Else Loc=5, Par=2
 Root=Child 32

You might also like