Information Science 2

Transcription

1 Information Science 2 - Basic Search Algorithms- Week 04 College of Information Science and Engineering Ritsumeikan University

2 Agenda Week 03 review Search algorithms on linear data structures - Linear search - Binary search Search algorithms on node-based data structures Quiz 2

3 Recall concepts from Week 03 Graphs, multigraphs Vertices, nodes Edges, links, arcs, loops Vertex degree (Hamiltonian) circuits Trees, binary trees 3

4 Class objectives Learn basic algorithms for searching on arrays and binary trees After this lecture and study, you must be able to: Understand and be able to describe the linear and binary search algorithms Understand and discuss the concepts of breadth-first and depth-first search Show how to construct an ordered binary tree 4

5 Searching linear data structures Problem formulation: Given an array a[left...right], find which (if any) component equals target, a given target value. Here, left and right are index values that define the domain of search Algorithms to solve the problem: Linear (sequential) search Binary search 5

6 Linear (sequential) search Main idea: To find which (if any) component of a[left...right] equals target: target = 10 a target = -5 Sequentially scan a, comparing each array item with target If a match is found, return the index of the matched element; otherwise return none start here start here a go through these stop here; return 8 go through these, to the end stop; return none 6

7 Linear search: Efficiency (complexity) analysis 1. For i = left,, right, repeat: 1.1. If target equals a[i], terminate with answer i 2. Terminate with answer none Let n = right left + 1 be the length of the array If the search is unsuccessful, step 1.1 is repeated n times Worst case (target not found) = n iterations If the search is successful, step 1.1 is repeated between 1 and n times Average case (target found) = n / 2 iterations Not really efficient! (For example, to select 1000 records from a database with totally records, one would have to make ~1000*10000/2 comparisons ) 7

8 Sorted arrays An array (or its part) is sorted if its components are in ascending order, i.e. each component is less than or equal to the component on its right: a[left] a[left +1] a[left +2] a[right] The meaning of the comparison x is less than or equal to y must be defined for each data type. For example, the most common cases: Meaning of for numbers: x is numerically less than or equal to y, i.e. x y Conventional meaning of for characters: x is same as or precedes y alphabetically For words: same as in the case of strings, e.g. bat is less than bath, which is less than bay 8

9 Binary search Main idea: To find which (if any) component of a sorted array a[left...right] equals target: Find middle, the middle of a Is a[middle] equal to target? if yes, terminate with middle Which half has the answer on the left or on the right from a[middle]? Keep only that half Repeat until target is found or all the middles are checked 1 st middle 4 th middle == target target = 10 a target = 25 a 3 rd middle 1 st middle 2 nd middle 2 nd middle 3 rd middle 4 th middle 9

10 Binary search: Efficiency 1. Set l = left, and set r = right Every cycle cuts the domain in half. Cost for the domain of size n = 2 k is k + 1 comparisons. Worst case (element not found): log 2 (n) + 1 iterations Average case (element found): log 2 (n) 1 iterations Example: search a 32-million-element array Linear search: on average, 16 million cycles Binary search: at most 25 cycles analysis 2. While l r, repeat (within 2): 2.1. Let m be an integer midway between l and r 2.2. If target equals a[m], terminate with m 2.3. If target is less than a[m], set r = m If target is greater than a[m], set l = m Terminate with none 10

11 11 Searching on trees The search algorithms we have learned so far are for arrays, not more complex node-based data structures Recall your lesson on data structures in the form of graphs and trees Movement through any of the graphs is by traversal moving from node to node via their links Surprisingly, the two ideas we use for searching on arrays ( check-the-elements-one-by-onesequentially and sort-then-search ) work in the case of searching on graphs such as trees, too

12 Depth and breadth Imagine a linear search on a graph, for example a tree Depending on the graph s structure, an ordinary linear search would often reach the end of a chain of connected nodes without checking all of the nodes To traverse in a graph, we thus need to define directions or algorithms for checking all the nodes in it There are two main directions in a graph, breadth and depth Breadth is across the graph, nodes of equal distance traversed from the origin (for example, the origin is often the root) Depth is moving away from the origin in number of edges traversed 12

13 13 Breadth-first search (BFS) The breadth-first search, as the name says, is a search across each set of nodes of equal distance from the origin The nodes on the tree graph to the right are numbered in the order of a breadth-first search from the root

14 14 Depth-first search (DFS) Depth first search searches every unsearched node in one direction. After reaching the deepest unsearched node, it traverses back to the nearest node with an unsearched subtree The search continues in the same direction to the deepest node on that side again, and repeats process until the origin has no unsearched subtrees

15 Ordered binary trees Recall that a binary tree is a structure, with a root node when not empty, in which each node may connect to up to two nodes its left and right subtrees A binary tree in which no two nodes have the same value may be called ordered if for every node X: The next left subtree value is less than that of X The next right subtree value is greater than that of X 15

16 Creating ordered binary trees A Make an ordered binary tree for a random string DKEPSAZTNVLC Start each at root; branch left for less than, right for greater than : C D E L K N New nodes can be added in any sequence. The tree is always ordered! No unlinking is required for search or insertion P S T Z V D is a new root node K>D; new right node on D E>D; E<K, new left on K P>D, P>K; new right on K S>D, S>K, S>P; new right on P A<D; new left on D Z>D, Z>K, Z>P, Z>S, new right on S T>D, T>K, T>P, T>S, T<Z, new left on Z For practice, show how to add N, V, L, and C 16

17 17 Search on an ordered binary tree A B D C E K N P S Search for entry T: T>D, T>K, T>P, T>S, T<Z T is found in 6 steps N T Z V Search for entry B: B<D, B>A, B<C no left node at C B is not on the tree yet but we have found the correct position, so we can insert it if necessary

18 Efficiency of search We will consider the efficiency of search algorithms in more detail in later classes Note however that search depends on the data structure used, and whether the data is ordered in a way that would be utilized Linear search is simple and works without sorting Binary search works on any sorted data structure, but sorting is often costly (i.e., slow) Binary trees are one way to efficiently solve problems of both sorting and searching Sorting on a graph, such as a tree, is not however always possible. So, there are a number of ways of searching, of which we have looked at depthfirst and breadth-first 18

19 Summary There are two fundamental approaches to searching on a data structure: checking the data one by one, as is, sequentially, and checking only the middle elements of the data, which has first been sorted The first approach (linear search) is simpler but is usually much less efficient than the second (the binary search) These approaches are applicable to both arrays and graphs. The search algorithms are, however, different BFS, DFS, and search on sorted binary trees are the main algorithms of search on graphs 19

20 20 Homework Read these slides Do the self-preparation assignments Learn the English terms new for you

21 21 Next class Sorting Algorithms - Bubble sort - Selection sort - Insertion sort Sorting algorithm efficiency

22 Quiz 02 22