Data Structures CSC212 (1) Dr Muhammad Hussain Lecture - Binary Search Tree ADT

(1)

Binary Search Tree

ADT

56

26

200

18

28

190

213

12

24

27

12

24

27

(2)

Binary Search Tree ADT (BST)

y

(

)

It is a binary

It is a binary tree

tree with the following properties

with the following properties

1

1. with each node associate a key

. with each node associate a key

1

1. with each node associate a key

. with each node associate a key

2

2. the key of each node is greater than the keys of the

. the key of each node is greater than the keys of the nodes

nodes

in its left

in its left subtree

subtree and it is less that the keys of

and it is less that the keys of the nodes in

the nodes in

its right

its right subtree

subtree

56

26

200

18

28

190

213

(3)

Note:

The property

The property 2

2 is called

is called

binary

binary--search

search--tree property

tree property

This property guarantees that:

-- The

The

minimum

is located at the

left

left--most

most

node.

-- The

The

maximum

is located at the

right

right--most

most

node.

56

26

200

i ht

tt

18

28

190

213

right

right--most

most

12

24

27

left

left--most

most

24

27

(4)

Why BST?

y

It speeds up search operation on a collection of data

It speeds up search operation on a collection of data elements

elements

Specification of Binary Search Tree ADT

Elements:

Elements: Any

Any valid data

valid data type

type

Structure:

Structure: A binary tree such that if N is any node in the tree then all

A binary tree such that if N is any node in the tree then all

Structure:

Structure: A binary tree such that if N is any node in the tree then all

A binary tree such that if N is any node in the tree then all

nodes in its left

nodes in its left subtree

subtree are smaller than N, and all nodes in its

are smaller than N, and all nodes in its

right

right subtree

subtree are larger than N.

are larger than N.

N t

A

d N i l

th

d M if k

l

f N i

Note

Note::

A node N is larger than the node M if key value of N is

larger than that of M and vice versa

..

Domain:

Domain: Number of elements is

Number of elements is bounded

bounded

Operations:

Operation

Operation SpecificationSpecification

void

void emptyempty()() Precondition: Precondition: nonenone..

Process:

(5)

Operation

Operation SpecificationSpecification Operation

Operation SpecificationSpecification

void

void findkeyfindkey ((intint k) k) Precondition: Precondition: none.none.

Process:

Process: searches the BST for a node whose key = k. If found then that searches the BST for a node whose key = k. If found then that node will be set as the current node and returns true. And if search failed, node will be set as the current node and returns true. And if search failed, ode wode w be se asbe se as e cu ee cu e ode a d e u s ue.ode a d e u s ue. dd sea csea c a ed,a ed, then (

then (11) BST empty then just return false; or () BST empty then just return false; or (22) BST not empty then ) BST not empty then current node is the node to which a node containing k would be attached current node is the node to which a node containing k would be attached as a child if it were added to BST and return false.

as a child if it were added to BST and return false. void

void insertinsert((intint k,k, Type Type valval)) Precondition: Precondition: BST not full.BST not full.

Process:

Process: ((11) ) if we already have a node with key = k then current retain if we already have a node with key = k then current retain its old value (the value prior to calling this operation) and return false; or its old value (the value prior to calling this operation) and return false; or ((22) insert a new node with the given key and data and setting it as current) insert a new node with the given key and data and setting it as current ((22) insert a new node with the given key and data and setting it as current ) insert a new node with the given key and data and setting it as current node, return true.

node, return true. void

void updateupdate((Type)Type) Precondition/Requires : Precondition/Requires : BST is not empty.BST is not empty.

Process:

Process: update the value of data of the current node key remainsupdate the value of data of the current node key remains

Process:

Process: update the value of data of the current node, key remains update the value of data of the current node, key remains unchanged.

unchanged. Type

Type retrieveretrieve()() Precondition: Precondition: BST is not emptyBST is not empty..

Process:

Process: returns data of the current node.returns data of the current node...

Process:

Process: returns data of the current node.returns data of the current node... bool

bool remove_keyremove_key((intint k)k) Precondition: Precondition: nonenone..

Process:

Process: removes the node containing the key = k, and in case BST is removes the node containing the key = k, and in case BST is not empty then sets the root as the current node. Returns true or false not empty then sets the root as the current node. Returns true or false p yp y depending on whether the operation was successful or not.

(6)

Represent ion of Binary Search Tree ADT

p

y

Since BST is a special

Since BST is a special kind binary

kind binary tree, it can be represented using

tree, it can be represented using

Linked List

--

Linked List

Note

Note ::

Array is not suitable for BST

Note

(7)

Implementation of BST

public class

BSTNode

<T> {

public class

BSTNode

<T> {

public int key;

public T data;

public BSTNode<T> left, right;

p

,

g

;

public BSTNode(int k, T val) {

key = k;

y

data = val;

left = right = null;

}

public BSTNode (int k, BSTNode<T> l, BSTNode<T> r) {

key = k;

left = l;

right = r;

}

(8)

public class

Flag

{

public class

Flag

{

boolean value;

/** Creates a new instance of Flag */

public Flag() {

p

g() {

value = false;

}

public Flag(boolean v){

p

g

value = v;

}

public boolean get_value (){

return value;

}

public void set_value(boolean v){

value = v;

}

(9)

public class

BST

<T> {

public class

BST

<T> {

BSTNode<T> root, current;

public BST()

private BSTNode<T> findparent (BSTNode<T> p)

private BSTNode<T> find_min(BSTNode<T> p)

private BSTNode<T> remove aux(int key, BSTNode<T> p, Flag

p

_

(

y,

p,

g

flag)

public boolean empty()

p

p y

public T retrieve ()

public boolean findkey(int tkey)

public boolean insert (int k, T val)

public boolean remove_key (int tkey)

public boolean update(int key, T data)

(10)

Implementation of Operations

private BSTNode<T>

findparent

(BSTNode<T> p) {

LinkStack<BSTNode<T>> stack = new LinkStack<BSTNode<T>>();

BSTNode<T> q = root;

q

;

while (q.right != p && q.left != p){

if (q.right != null) stack.push(q.right);

if (q.left != null)

q

q = q.left;

else

q = stack.pop();

}

return q;

}

private BSTNode<T>

find_min

(BSTNode<T> p){

if (p == null) return null;

while (p.left != null){

while (p.left ! null){

p = p.left;

}

(11)

private BSTNode<T> remove_aux(int key, BSTNode<T> p, Flag flag) {

BSTNode<T> q, child = null; if (p == null)

ll return null; if (key < p.key)

p.left = remove_aux(key, p.left, flag); else if (key > p.key)

p right = remove aux(key p right flag);

Start with node

p

and

remove the node whose

k

i ‘

k

’

i

l

p.right = remove_aux(key, p.right, flag); else {

flag.set_value(true);

if (p.left != null && p.right != null){ q = find min(p.right);

key is ‘

key

’ recursively.

q _ p g

p.key = q.key; p.data = q.data;

p.right = remove_aux(q.key, p.right, flag); }

else {

if (p.right == null) child = p.left;

else if (p.left == null) child = p right; child = p.right; return child; } } return p;p }

(12)

Implementation of Operations

public BST()

{

root = current = null;

}

public

public boolean

boolean empty()

empty()

{

return root == null ? true: false;

}

{

return

return current.data

current.data;

;

}

(13)

public boolean

findkey

(int tkey){

BSTNode<T> p,q;

p = root; q = root;

p

; q

;

if (empty()) return false;

while (p != null){

q = p;

q

p

if (p.key == tkey){

current = p;

return true;

}

else if (tkey < p.key)

p = p.left;

else

p = p.right;

}

t

current = q;

return false;

}

(14)

public boolean

insert

(int k, T val){ BSTNode<T> p, q = current;

if (findkey(k)){ if (findkey(k)){

current = q;

return false; /* key already in the BST */ }

p = new BSTNode<T>(k, val); if (empty()) { root = current = p; return true; return true; } else {

/* current is pointing to the parent of the new key. if (k k ) if (k < current.key) current.left = p; else current.right = p; cu e t. g t p; current = p; return true; } } }

(15)

Implementation of Operations

public boolean

remove_key

(int tkey){

Flag removed = new Flag(false);

BSTNode<T> p;

p = remove_aux(tkey, root, removed);

current = root = p;

return removed get value();

return removed.get_value();

}