searching and binary search trees csci 3333 data structures
TRANSCRIPT
Searching andBinary Search Trees
CSCI 3333 Data Structures
Acknowledgement
Dr. Yue Mr. Charles Moen Dr. Wei Ding Ms. Krishani Abeysekera Dr. Michael Goodrich Dr. Richard F. Gilberg
Searching
Google: era of searching! Many type of searching:
Search engines: best match. Key searching: searching for records
with specified key values. Keys are usually assumed to come from a
total order (e.g. integers or strings) Keys are usually assumed to be unique.
No two records have the same key.
Naïve Linear Search
Algorithm LinearSearch(r, key)Input: r: an array of record. Each record
contains a unique key. key: key to be found.
Output: i: the index such that r[i] contains the key, or -1 if not found.
foreach element in r with index i if r[i].key = key return i;end foreachreturn -1
Time Complexity
Operations Average Case
Worst Case
Find O(n) O(n)
Insert O(1) O(1)
Delete O(n) O(n)
Sorted order traversal
Need to sort first
Need to sort first
Naïve Linear Search
Linear time in finding! Only suitable when n is very small. No ‘pre-processing’.
Binary Search
Assume the array has already been sorted in ascending key value.
Example: find(7)
1 3 4 5 7 8 9 11 14 16 18 19
1 3 4 5 7 8 9 11 14 16 18 19
1 3 4 5 7 8 9 11 14 16 18 19
1 3 4 5 7 8 9 11 14 16 18 19
0
0
0
0
ml h
ml h
ml h
lm h
Binary Search Algorithm
Algorithm BinarySearch(r, key)Input: r: an array of record sorted by its key values.
Each record contains a unique key. key: key to be found.
Output: i: the index such that r[i] contains the key, or -1 if not found.
low = 0; high = r.size – 1while (low <= high) do mid = (high – low) / 2 if r[mid].key > key then high = mid-1 if r[mid].key = key then return mid; if r[mid].key < key then low = mid + 1end whilereturn -1;
Time Complexity
Operations Average Case
Worst Case
Find O(lg n) O(lg n)
Insert O(n) O(n)
Delete O(n) O(n)
Sorted order traversal
O(n) O(n)
Binary Search
O(lg n) in finding! Especially suitable for relatively static sets
of records. Question: can we find a searching
algorithm of O(1)? Question: can we find a searching
algorithm of O(lg N), where the time complexity for insert and delete is better? Average case Worst case
Binary Search Trees
A binary search tree (BST) is a binary tree which has the following properties: Each node has a unique key value. The left subtree of a node contains only
values less than the node's value. The right subtree of a node contains
only key values greater than the node's value.
• Each subtree is itself a binary search Each subtree is itself a binary search tree.tree.
BST
An inorder traversal of a binary search trees visits the keys in increasing order.
Note that there are variations in the formulation of BST. The one defined in the textbook is somewhat different and is best mapped to implement a dictionary. Duplicate key values allowed. Records stored in leaf nodes. Leaf nodes store no key.
The version of BST used here is more basic, easier to understand, and more popular.
Searching a BST
Similar to binary search. Each key comparison with a node will
result in one of these: target < node key => search left subtree. target = node key => found! target > node key => search right subtree.
Difference with binary search: do not always eliminate about half of the candidates. The BST may not be balanced.
BST Find Algorithm (Recursive)
Algorithm Find(r, target)Input: r: root of a BST. target: key to be found.Output: p: the node in the BST that contains the
target; null if not found.if r = null return null;if target = r.key return r;if target < r.key return find(r.leftChild(),target)else // target > r.key
return find(r.rightChild(),target)end if
BST Find Algorithm (Iterative)Algorithm Find(r, target)Input: r: root of a BST. target: key to be found.Output: p: the node in the BST that contains the
target; null if not found.result = rwhile result != null do
if target = result.key return result;if target < result.key then
result = result.leftChild()else // target > r.key
result = result.rightChild()end if
end whilereturn result
Time Complexity
Depend on the shape of the BST. Worst case: O(n) for unbalanced
trees. Average case: O(lg N)
BST Insert
Insert a record rec with key rec.key. Idea: search for rec.key in the BST. If found => error (keys are
supposed to be unique) If not found => ready to insert
(however, need to remember the parent node for insertion).
BST Insert Algorithm (Iterative)
Algorithm Insert(r, rec)Input: r: root of a BST. rec: record to be found.Output: whether the insertion is successful.Side Effect: r may be updated.curr = rparent = null// find the location for insertion.while (curr != null) do if curr.key = rec.key then
return false // duplicate key: unsuccessful insertion else if rec.key < curr.key then curr = curr.leftChild() parent = curr else // rec.key > curr.key curr = curr.rightChild() parent = curr end ifend while
BST Insert (Continue)
// create new node for inserrtion newNode = new Node(rec)newNode.parent = parent// Insertion.if parent = null then r = newNode;else if rec.key < parent.key then parent.leftChild = newNodeelse parent.rightChild = newNodeend ifreturn true
BST Delete
More complicated Cannot delete a parent without
arranging for the children! Who take care of the children?
Grandparent. If there is no grandparent? The root is
deleted and a child will become the root.
Need to keep track of the parent of the node to be deleted.
BST Delete
Find the node with the key to be deleted. If not found, deletion is not successful. Deletion of the node p:
No child: simple deletion Single child: connect the parent of p to the
single child of p. Both children:
Connect the parent of p to the right child of p. Connect the left child of p as the left child of
the immediate successor of p.
BST Delete AlgorithmAlgorithm Delete(r, target)Input: r: root of a BST. target: key of the record to be
found.Output: whether the deletion is successful.Side Effect: r is updated if the root node is deleted.
curr = r; parent = null// find the location for insertion.while (curr != null and curr.key != target) do if target < curr.key then curr = curr.left parent = curr else // target > curr.key curr = curr.right parent = curr end ifend while
BST Delete Algorithm (Continue)if curr = null then return false; // not foundend if
if curr.right = null then // no right child if parent = null then // root deleted r = r.left else if target < parent.key then parent.left = curr.left else parent.right = curr.left end if end ifelse
BST Delete Algorithm (Continue)
// has right child if curr.left = null then // has a right child but no left child if parent = null then // root deleted r = r.right else if target < parent.key then parent.left = curr.right else parent.right = curr.right end if end if else
BST Delete Algorithm (Continue)
// has both left and right children // find immediate successor. immedSucc = curr.right while (immedSucc.left != null) immedSucc = immedSucc.left end while immedSucc.left = curr.left
BST Delete Algorithm (Continue)
if parent = null then // root deleted r = r.right else if target < parent.key then parent.left = curr.right else parent.right = curr.right end if end if end if delete currend if
Time Complexity
Worst case: O(N) Result in unbalanced tree.
Time Complexity (general BST)
Operations Average Case
Worst Case
Find O(lg n) O(n)
Insert O(lg n) O(n)
Delete O(lg n) O(n)
Sorted order traversal
O(n) O(n)
Unbalanced BST
Two approaches: Reorganization when the trees become
very unbalanced. Use balanced BST
Balanced BST Many potential definitions. Height = O(lg n)
Time Complexity (balanced BST)
Operations Average Case
Worst Case
Find O(lg n) O(lg n)
Insert O(lg n) O(lg n)
Delete O(lg n) O(lg n)
Sorted order traversal
O(n) O(lg n)
Questions and Comments?