Binary Search Trees - PowerPoint PPT Presentation

1 / 10
About This Presentation
Title:

Binary Search Trees

Description:

Binary Search Trees (BST) ... BST can be used to efficiently handle many types higher level data types like sets, etc. BST is usually much more efficient than a ... – PowerPoint PPT presentation

Number of Views:122
Avg rating:3.0/5.0
Slides: 11
Provided by: facwebIit
Category:
Tags: binary | bst | search | trees

less

Transcript and Presenter's Notes

Title: Binary Search Trees


1
Binary Search Trees
2
Binary Search Trees (BST)
  • A binary search tree is a binary tree that is
    either empty or in which each node contains a key
    that satisfies the following conditions
  • All keys (if any) in the left subtree of the root
    precede (are less than or equal to) the key of
    the root.
  • The key in the root precedes (is less than) all
    keys (if any) in its right subtree.
  • The left and right subtrees of the root are again
    binary search trees.
  • Sometimes we store only distinct elements and
    store lt and gt elements in left and right subtrees
    respectively

3
Examples of BST
r
50
Right subtree of root r
Left subtree of root r
75
30
53
45
12
80
20
12
20
35
48
85
78
Inorder Traversal of a BST prints the key values
in ascending order
4
BST keys need not only be integers(Need a
comparison operator on keys)
a
c
b
e
d
f
i
h
g
k
j
5
BST ADT
  • typedef int ElementType
  • struct TreeNode
  • ElementType Element
  • struct TreeNode Left
  • struct TreeNode Right
  • typedef struct TreeNode Position
  • typedef struct TreeNode SearchTree

SearchTree MakeEmpty( SearchTree T ) Position
Find( ElementType X, SearchTree T ) Position
FindMin( SearchTree T ) Position FindMax(
SearchTree T ) SearchTree Insert( ElementType
X, SearchTree T ) SearchTree Delete(
ElementType X, SearchTree T ) ElementType
Retrieve( Position P )
Note BST could maintain pointers to other
fields/records. For example, a Roll Number
based BST for student records. Other information
may be stored in the BST record or may be
stored separately and a pointer to it kept in the
BST.
6
MakeEmpty, Find
  • SearchTree
  • MakeEmpty( SearchTree T )
  • if( T ! NULL )
  • MakeEmpty( T-gtLeft )
  • MakeEmpty( T-gtRight )
  • free( T )
  • return NULL

Position Find( ElementType X, SearchTree T )
if ( T NULL ) return NULL if (X
T-gtElement) return T if ( X lt T-gtElement
) return Find( X, T-gtLeft ) if ( X gt
T-gtElement ) return Find( X, T-gtRight
)
7
FindMin, FindMax, Retrieve
  • Position
  • FindMin( SearchTree T )
  • if( T NULL )
  • return NULL
  • else
  • if( T-gtLeft NULL )
  • return T
  • else
  • return FindMin( T-gtLeft )

Position FindMax( SearchTree T ) /
Non-recursive algorithm / if( T ! NULL )
while( T-gtRight ! NULL ) T
T-gtRight return T
ElementType Retrieve( Position P )
return P-gtElement
8
Insert
SearchTree Insert( ElementType X, SearchTree T
) if( T NULL ) / Create and
return a one-node tree / T malloc(
sizeof( struct TreeNode ) ) if( T
NULL ) FatalError( "Out of space!!!"
) else T-gtElement X
T-gtLeft T-gtRight NULL
else if( X lt T-gtElement )
T-gtLeft Insert( X, T-gtLeft ) else
if( X gt T-gtElement ) T-gtRight Insert(
X, T-gtRight ) / Else X is in the tree
already we'll do nothing / return T /
Do not forget this line!! /
If we wish to keep duplicates of same key, we
can keep counters or insert on one side of the
BST (left or right subtree)
9
Delete
else / Found element to be deleted / if(
T-gtLeft T-gtRight ) / 2 children / /
Replace with smallest in right subtree /
TmpCell FindMin( T-gtRight ) T-gtElement
TmpCell-gtElement T-gtRight Delete(
T-gtElement, T-gtRight ) else / One or
zero children / TmpCell T if(
T-gtLeft NULL ) T T-gtRight else if(
T-gtRight NULL ) T T-gtLeft free(
TmpCell ) return T
SearchTree Delete( ElementType X, SearchTree T
) Position TmpCell if( T NULL )
Error( "Element not found" ) else if( X lt
T-gtElement ) / Go left / T-gtLeft
Delete( X, T-gtLeft ) else if( X gt T-gtElement
) / Go right / T-gtRight Delete( X,
T-gtRight )
10
Some Notes
  • BST can be used to efficiently handle many types
    higher level data types like sets, etc.
  • BST is usually much more efficient than a singly
    linked list for such operations due to
    partitioning of search space for various
    operations.
  • The average number of steps is of the order of
    log n where n nodes are there in the tree
  • However the worst case can be of the order of n
    when the BS is skewed (like a chain) as shown in
    the figure alongside. This depends on the order
    of the insert and delete operations.

50
75
80
85
Write a Comment
User Comments (0)
About PowerShow.com