24/3/00SEM107 - © Kamin & ReddyClass 16 - Searching - 1 Class 16 - Searching r Linear search r Binary search r Binary search trees

24/3/00SEM107 - © Kamin & ReddyClass 16 - Searching - 2 The problem r Given a set of data items {k 1, k 2,..., k n } - called keys - determine whether another key k occurs in the set. r (Variation: Start with pairs (k 1,v 1 ),..., (k n,v n ). Then given k, determine whether k = k i for some i; return v i.)

24/3/00SEM107 - © Kamin & ReddyClass 16 - Searching - 3 “Data structures” r We will consider two costs: m The cost of inserting the keys k i in some data structure (array, list, whatever) m The cost of searching for k r Cost depends primarily on how data are stored. r Best data structure can depend upon ratio of searches to insertions, how searches and insertions are distributed.

24/3/00SEM107 - © Kamin & ReddyClass 16 - Searching - 4 Data structures (cont.) r We will look at three data structures: m Linear storage in array - unsorted m Linear storage in array - sorted m Binary tree

24/3/00SEM107 - © Kamin & ReddyClass 16 - Searching - 5 Linear storage, unsorted Store data in array keys[0...count], unsorted 1. To insert key k : keys[count] = k; count++; 2. To find key k : for (i=0; i<count; i++) if (keys[i] == k) return i; Cost of inserting new key: O(1) Cost of searching for key: O(n)

24/3/00SEM107 - © Kamin & ReddyClass 16 - Searching - 6 Linear storage, sorted Store data in array keys[0...count], sorted 1. To insert key k : insert in correct order, as in insertion sort 2. To find key k : same as above Cost of inserting new key: O(n) Cost of searching for key: O(n)

24/3/00SEM107 - © Kamin & ReddyClass 16 - Searching - 7 Binary search Cost of searching in sorted array can be dramatically reduced by “divide and conquer”. boolean bsearch (int k, int[] keys, int i, int j) // find whether k occurs in keys[i..j]] Can cut size of subarray in half with one comparison:

24/3/00SEM107 - © Kamin & ReddyClass 16 - Searching - 8 Binary search (cont.) r Cases: m k == keys[m]: done m k < keys[m]: k occurs in keys[i..m-1] (if at all) m k > keys[m]: k occurs in keys[m+1..j] (if at all) keys i jm m = (j+i)/2

24/3/00SEM107 - © Kamin & ReddyClass 16 - Searching - 9 Binary search (cont.) boolean bsearch (int k, int[] keys, int i, int j) { // find whether k occurs in keys[i..j] int m = (i+j)/2; if (i > j) return false; if (k == keys[m]) return true; if (k < keys[m]) return bsearch(k, keys, i, m-1); return bsearch(k, keys, m+1, j); }

24/3/00SEM107 - © Kamin & ReddyClass 16 - Searching - 10 Efficiency of binary search # of comparisons = 2 * # of times array can be divided in half: log 2 n E.g. If n = 1,000,000, worst-case cost of linear search = 1,000,000; worst-case cost of binary search = 40.

24/3/00SEM107 - © Kamin & ReddyClass 16 - Searching - 11 Binary trees Can obtain log n insertions and searches (on average) by storing data in binary tree structure. Def. A binary tree is a structure consisting of a number (the label ) and two binary trees, the left and right subtrees. Both are optional.

24/3/00SEM107 - © Kamin & ReddyClass 16 - Searching - 12 Binary trees (cont.) Def. Size of tree t = number of nodes (i.e. numbers) in t.

24/3/00SEM107 - © Kamin & ReddyClass 16 - Searching - 13 Binary search trees r Def. A binary search tree (BST) is a binary tree with the following property: its label is greater than any of the labels in its left subtree and less than any labels in its right subtree. Furthermore, its left and right subtrees are binary search trees. r Example: tree on previous slide

24/3/00SEM107 - © Kamin & ReddyClass 16 - Searching - 14 Balanced BST’s r A binary search tree is balanced if its left and right subtrees are of approximately equal size, and are both balanced. r Def. The height of a tree is the length of the longest path from the top to the bottom. r Observation If a BST of size n is balanced, its height  log 2 n.

24/3/00SEM107 - © Kamin & ReddyClass 16 - Searching - 15 Searching in BST To find k in BST T = Cases: m k = k’: Done m k < k’: Search in T1 (if it exists) m k > k’: Search in T2 (if it exists) Time (in worst case) is proportional to height of T. If T is balanced, time is order log 2 n. k’ T1T2

24/3/00SEM107 - © Kamin & ReddyClass 16 - Searching - 16 Inserting in BST To insert k in BST T = Cases: m k = k’: Done (do nothing) m k < k’: Insert in T1. If T1 absent, add new left subtree containing just k m k > k’: Insert in T2. If T2 absent, add new right subtree containing just k If T is balanced, time is order log 2 n. k’ T1T2

24/3/00SEM107 - © Kamin & ReddyClass 16 - Searching - 17 Implementing BST’s r Represent trees by objects containing an integer and two references to other trees. (Recall that a reference to an object can be null, meaning it doesn’t really point to anything.) class BinarySearchTree { int val; BinarySearchTree left, right; BinarySearchTree (int v, BinarySearchTree l, BinarySearchTree r) { val = v; left = l; right = r; }

24/3/00SEM107 - © Kamin & ReddyClass 16 - Searching - 18 Implementing BST’s (cont.)  Could make the search and insert operations instance methods, but, as for lists, we will instead make them class methods of a separate class, BST. class BST { static BinarySearchTree makeBST (int k) { return new BinarySearchTree(k, null, null); }

24/3/00SEM107 - © Kamin & ReddyClass 16 - Searching - 19 Implementing BST’s (cont.) static boolean search (int k, BinarySearchTree t) { if (t == null) return false; else if (k == t.val) return true; else if (k < t.val) return search(k, t.left); else return search(k, t.right); }

24/3/00SEM107 - © Kamin & ReddyClass 16 - Searching - 20 Implementing BST’s (cont.) static void insert (int k, BinarySearchTree t) { // t must be non-null if (k == t.val) return; if (k < t.val) if (t.left == null) t.left = makeBST(k); else insert(k, t.left); else if (t.right == null) t.right = makeBST(k); else insert(k, t.right); }

24/3/00SEM107 - © Kamin & ReddyClass 16 - Searching - 21 Implementing BST’s (cont.) public static void main (String[] args) { BinarySearchTree T = BST.makeBST(7); BST.insert(3,T); BST.insert(5,T); BST.insert(13,T); BST.insert(11,T); BST.insert(9,T); BST.insert(1,T); System.out.print(BST.search(3, T)); // true System.out.print(BST.search(4, T)); // false } Here is an example of using these operations: