Presentation is loading. Please wait.

Presentation is loading. Please wait.

Chapter 2.8 Search Algorithms. Array Search –An array contains a certain number of records –Each record is identified by a certain key –One searches the.

Similar presentations


Presentation on theme: "Chapter 2.8 Search Algorithms. Array Search –An array contains a certain number of records –Each record is identified by a certain key –One searches the."— Presentation transcript:

1 Chapter 2.8 Search Algorithms

2 Array Search –An array contains a certain number of records –Each record is identified by a certain key –One searches the record with a given key String Search –A text is represented by an array of characters –One searches one or all occurrences of a certain string

3 Search Algorithms Array Search –An array contains a certain number of records –Each record is identified by a certain key –One searches the record with a given key String Search –A text is represented by an array of characters –One searches one or all occurrences of a certain string

4 Array Search PROCEDURE Search –Two parameters: The Array to be searched –Contains n Items –Index in the range 0..n –Item with index 0 is not used The Key of the Item to be found –Search returns a Cardinal value the index of the Item where the key has been found if the key has not been found, 0.

5 Array Search TYPE ArrayOfItems = ARRAY[0..n] OF Item; (* By convention, the element with index 0 is not used *) Item = RECORD Key : KeyType (* any ordinal type *); Other record fields ; END;

6 Straight Search VAR PROCEDURE Search ( A: ARRAY OF Item, Key: KeyType): CARDINAL; VARi : CARDINAL; BEGIN i := HIGH(A); WHILE A[i].Key # Key AND i # 0DO DEC(i) END; RETURNi END Search;

7 Straight Search VAR PROCEDURE Search ( A: ARRAY OF Item, VARi : CARDINAL; BEGIN i := HIGH(A); WHILE A[i].Key # Key AND i # 0DO DEC(i) END; RETURNi END Search; Key: KeyType): CARDINAL;

8 Sentinel Search PROCEDURE Search ( VAR A: ARRAY OF Item, Key: KeyType): CARDINAL; VARi : CARDINAL; BEGIN i := HIGH(A); A[0].Key := Key; WHILE A[i].Key # KeyDODEC(i)END; RETURNi END Search;

9 Binary Search # elements > 1 Binary Search No Yes # elements > 1 No Yes Key < Key middle No Yes Key = Key element Binary Search right half Binary Search left half Not Found

10 Binary Search (1) PROCEDURE Search(VAR a: ARRAY OF Item, Key:KeyType):CARDINAL; VAR Min,Max,m: CARDINAL; PROCEDURE src(Min,Max: CARDINAL); … END src; BEGIN Min := 1; Max := HIGH(a); src(Min,Max); IF a[m].Key = Key THEN RETURN m ELSE RETURN 0 END END Search;

11 Binary Search (2) PROCEDURE Src(Min,Max : CARDINAL); BEGIN m := (Min+Max) DIV 2; IF Min # Max THEN IF a[m].Key >= Key THEN src(Min,m) ELSE src(m+1,Max) END; END END Src;

12 Iterative Binary Search PROCEDURE Search(VAR a: ARRAY OF Item, Key:KeyType):CARDINAL; VAR Min,Max,m: CARDINAL; BEGIN Min := 1; Max := HIGH(a); WHILE Min < Max DO m := (Min+Max) DIV 2; IF a[m].Key >= Key THEN Max := m ELSE Min := m+1 END; (* IF *) END; (* WHILE *) IF a[m].Key = Key THEN RETURN m ELSE RETURN 0 END END Search;

13 Array Search Performance (Number of comparisons) Unordered Array –Straight search : 2n –Sentinel search : n Ordered Array – Binary search : log 2 n

14 Search Algorithms Array Search –An array contains a certain number of records –Each record is identified by a certain key –One searches the record with a given key String Search –A text is represented by an array of characters –One searches one or all occurrences of a certain string

15 String Search The problem: Find a given string in a text. Data structures: Text : ARRAY[1..TextSize] OF CHAR; String : ARRAY[1..StringSize] OF CHAR; The Algorithms: –Brute Force –Knuth, Morris & Pratt (KPM - 1974) –Boyer & Moore (BM - 1977)

16 String Search by Brute Force this algorithm tries to find a string string String matched OR Text exhausted Move to next character in Text End of Text reached ? No WHILE current char.in Text # String[1] WHILE char. in Text = char. in String Move to next character pair

17 Brute Force String Search (Straightforward coding) PROCEDURE Search (VAR Text: TextType; TLength:CARDINAL; VAR String: StringType; SLength:CARDINAL):CARDINAL; VAR j, jmax : CARDINAL; BEGIN j := 0; jmax := TLength - SLength; REPEAT WHILE (Text[j] # String[1]) AND (j <= jmax) DO j := j+1 END; IF j <= jmax THEN i := 2; WHILE (Text[j+i] = String[i]) AND (i < SLength) DO i := i+1 END; END; (* IF *) j := j + 1; UNTIL (i = SLength) OR (j > jmax); RETURN j - 1 END Search;

18 String Search (1) by the KMP algorithm GATCGATCAGCAATCATCATCACATC ATCATCACAT Mismatch in first position of string, Move string 1 position in text

19 String Search(2) by the KMP algorithm GATCGATCAGCAATCATCATCACATC ATCATCACAT Mismatch in fourth position of string, Move string 4 positions in text

20 String Search(3) by the KMP algorithm GATCGATCAGCAATCATCATCACATC ATCATCACAT Mismatch in fifth position of string, Move string 4 positions in text

21 String Search(4) by the KMP algorithm GATCGATCAGCAATCATCATCACATC ATCATCACAT Mismatch in first position of string, Move string 1 position in text

22 String Search(5) by the KMP algorithm GATCGATCAGCAATCATCATCACATC ATCATCACAT Mismatch in first position of string, Move string 1 position in text

23 String Search(6) by the KMP algorithm GATCGATCAGCAATCATCATCACATC ATCATCACAT Mismatch in second position of string, Move string 1 position in text

24 String Search(7) by the KMP algorithm GATCGATCAGCAATCATCATCACATC ATCATCACAT Mismatch in eight position of string, Move string 3 positions in text

25 String Search(8) by the KMP algorithm GATCGATCAGCAATCATCATCACATC ATCATCACAT String found !

26 The KMP algorithm The Next function A T C A T C A C A T 1 ? ? ? ? ? ? ? ? ? Step: x x x A x x x x x x x x x x x x x / A T C A T C A C A T

27 The KMP algorithm The Next function A T C A T C A C A T 1 1 ? ? ? ? ? ? ? ? Step: x x x A T x x x x x x x x x x x x / A T C A T C A C A T

28 The KMP algorithm The Next function A T C A T C A C A T 1 1 2 ? ? ? ? ? ? ? Step: x x x A T C x x x x x x x x x x x / A T C A T C A C A T

29 The KMP algorithm The Next function A T C A T C A C A T 1 1 2 4 ? ? ? ? ? ? Step: x x x A T C A x x x x x x x x x x / A T C A T C A C A T

30 The KMP algorithm The Next function A T C A T C A C A T 1 1 2 4 4 ? ? ? ? ? Step: x x x A T C A T x x x x x x x x x / A T C A T C A C A T

31 The KMP algorithm The Next function A T C A T C A C A T 1 1 2 4 4 5 ? ? ? ? Step: x x x A T C A T C x x x x x x x x / A T C A T C A C A T

32 The KMP algorithm The Next function A T C A T C A C A T 1 1 2 4 4 5 7 ? ? ? Step: x x x A T C A T C A x x x x x x x / A T C A T C A

33 The KMP algorithm The Next function A T C A T C A C A T 1 1 2 4 4 5 7 3 ? ? Step: x x x A T C A T C A C x x x x x x / A T C A T C A C A T

34 The KMP algorithm The Next function A T C A T C A C A T 1 1 2 4 4 5 7 3 9 ? Step: x x x A T C A T C A C A x x x x x / A T C A T

35 The KMP algorithm The Next function A T C A T C A C A T 1 1 2 4 4 5 7 3 9 9 Step: x x x A T C A T C A C A T x x x x / A T C A T

36 The KMP algorithm The Next function A T C A T C A C A T String: 1 1 2 4 4 5 7 3 9 9 Step: 0 1 1 0 1 1 0 5 0 1 Next: i = 1 2 3 4 5 6 7 8 9 10 Next[i] = i – Step[i]

37 Computation of the Next table i := 1; k := 0; Next[1] := 0; WHILE i < SLength DO WHILE (k > 0) AND (String[i]#String[k]) DO k := Next[k] END; (* WHILE *) k := k + 1; i := i + 1; IF String[i] = String[k] THEN Next[i] := Next[k] ELSE Next[i] := k END; (* IF *) END; (* WHILE *)

38 The KMP algorithm Building the Next function A T C A T C A C A T String 0 Next i := 1; k := 0; Next[1] := 0; WHILE i < SLength DO WHILE (k > 0) AND (String[i]#String[k]) DO k := Next[k] END; (* WHILE *) k := k + 1; i := i + 1; IF String[i] = String[k] THEN Next[i] := Next[k] ELSE Next[i] := k END; (* IF *) END; (* WHILE *) i : 1 k : 0

39 The KMP algorithm Building the Next function A T C A T C A C A T String 0 Next i := 1; k := 0; Next[1] := 0; WHILE i < SLength DO WHILE (k > 0) AND (String[i]#String[k]) DO k := Next[k] END; (* WHILE *) k := k + 1; i := i + 1; IF String[i] = String[k] THEN Next[i] := Next[k] ELSE Next[i] := k END; (* IF *) END; (* WHILE *) i : 1 k : 0

40 The KMP algorithm Building the Next function A T C A T C A C A T String 0 1 Next i := 1; k := 0; Next[1] := 0; WHILE i < SLength DO WHILE (k > 0) AND (String[i]#String[k]) DO k := Next[k] END; (* WHILE *) k := k + 1; i := i + 1; IF String[i] = String[k] THEN Next[i] := Next[k] ELSE Next[i] := k END; (* IF *) END; (* WHILE *) i : 1 > 2 k : 0 > 1

41 The KMP algorithm Building the Next function A T C A T C A C A T String 0 1 Next i := 1; k := 0; Next[1] := 0; WHILE i < SLength DO WHILE (k > 0) AND (String[i]#String[k]) DO k := Next[k] END; (* WHILE *) k := k + 1; i := i + 1; IF String[i] = String[k] THEN Next[i] := Next[k] ELSE Next[i] := k END; (* IF *) END; (* WHILE *) i : 2 k : 1 > 0

42 The KMP algorithm Building the Next function A T C A T C A C A T String 0 1 1 Next i := 1; k := 0; Next[1] := 0; WHILE i < SLength DO WHILE (k > 0) AND (String[i]#String[k]) DO k := Next[k] END; (* WHILE *) k := k + 1; i := i + 1; IF String[i] = String[k] THEN Next[i] := Next[k] ELSE Next[i] := k END; (* IF *) END; (* WHILE *) i : 2 > 3 k : 0 > 1

43 The KMP algorithm Building the Next function A T C A T C A C A T String 0 1 1 Next i := 1; k := 0; Next[1] := 0; WHILE i < SLength DO WHILE (k > 0) AND (String[i]#String[k]) DO k := Next[k] END; (* WHILE *) k := k + 1; i := i + 1; IF String[i] = String[k] THEN Next[i] := Next[k] ELSE Next[i] := k END; (* IF *) END; (* WHILE *) i : 3 k : 1 > 0

44 The KMP algorithm Building the Next function A T C A T C A C A T String 0 1 1 0 Next i := 1; k := 0; Next[1] := 0; WHILE i < SLength DO WHILE (k > 0) AND (String[i]#String[k]) DO k := Next[k] END; (* WHILE *) k := k + 1; i := i + 1; IF String[i] = String[k] THEN Next[i] := Next[k] ELSE Next[i] := k END; (* IF *) END; (* WHILE *) i : 3 > 4 k : 0 > 1

45 The KMP algorithm Building the Next function A T C A T C A C A T String 0 1 1 0 Next i := 1; k := 0; Next[1] := 0; WHILE i < SLength DO WHILE (k > 0) AND (String[i]#String[k]) DO k := Next[k] END; (* WHILE *) k := k + 1; i := i + 1; IF String[i] = String[k] THEN Next[i] := Next[k] ELSE Next[i] := k END; (* IF *) END; (* WHILE *) i : 4 k : 1

46 The KMP algorithm Building the Next function A T C A T C A C A T String 0 1 1 0 Next i := 1; k := 0; Next[1] := 0; WHILE i < SLength DO WHILE (k > 0) AND (String[i]#String[k]) DO k := Next[k] END; (* WHILE *) k := k + 1; i := i + 1; IF String[i] = String[k] THEN Next[i] := Next[k] ELSE Next[i] := k END; (* IF *) END; (* WHILE *) i : 4 > 5 k : 1 > 2

47 The KMP algorithm Building the Next function A T C A T C A C A T String 0 1 1 0 1 Next i := 1; k := 0; Next[1] := 0; WHILE i < SLength DO WHILE (k > 0) AND (String[i]#String[k]) DO k := Next[k] END; (* WHILE *) k := k + 1; i := i + 1; IF String[i] = String[k] THEN Next[i] := Next[k] ELSE Next[i] := k END; (* IF *) END; (* WHILE *) i : 5 k : 2

48 The KMP algorithm Building the Next function A T C A T C A C A T String 0 1 1 Next i := 1; k := 0; Next[1] := 0; WHILE i < SLength DO WHILE (k > 0) AND (String[i]#String[k]) DO k := Next[k] END; (* WHILE *) k := k + 1; i := i + 1; IF String[i] = String[k] THEN Next[i] := Next[k] ELSE Next[i] := k END; (* IF *) END; (* WHILE *) i : 5 > 6 k : 2 > 3

49 The KMP algorithm Building the Next function A T C A T C A C A T String 0 1 1 Next i := 1; k := 0; Next[1] := 0; WHILE i < SLength DO WHILE (k > 0) AND (String[i]#String[k]) DO k := Next[k] END; (* WHILE *) k := k + 1; i := i + 1; IF String[i] = String[k] THEN Next[i] := Next[k] ELSE Next[i] := k END; (* IF *) END; (* WHILE *) i : 6 k : 3

50 The KMP algorithm Building the Next function A T C A T C A C A T String 0 1 1 0 1 1 0 Next i := 1; k := 0; Next[1] := 0; WHILE i < SLength DO WHILE (k > 0) AND (String[i]#String[k]) DO k := Next[k] END; (* WHILE *) k := k + 1; i := i + 1; IF String[i] = String[k] THEN Next[i] := Next[k] ELSE Next[i] := k END; (* IF *) END; (* WHILE *) i : 6 > 7 k : 3 > 4

51 The KMP algorithm Building the Next function A T C A T C A C A T String 0 1 1 0 1 1 0 Next i := 1; k := 0; Next[1] := 0; WHILE i < SLength DO WHILE (k > 0) AND (String[i]#String[k]) DO k := Next[k] END; (* WHILE *) k := k + 1; i := i + 1; IF String[i] = String[k] THEN Next[i] := Next[k] ELSE Next[i] := k END; (* IF *) END; (* WHILE *) i : 7 k : 4

52 The KMP algorithm Building the Next function A T C A T C A C A T String 0 1 1 0 1 1 0 5 Next i := 1; k := 0; Next[1] := 0; WHILE i < SLength DO WHILE (k > 0) AND (String[i]#String[k]) DO k := Next[k] END; (* WHILE *) k := k + 1; i := i + 1; IF String[i] = String[k] THEN Next[i] := Next[k] ELSE Next[i] := k END; (* IF *) END; (* WHILE *) i : 7 > 8 k : 4 > 5

53 The KMP algorithm Building the Next function A T C A T C A C A T String 0 1 1 0 1 1 0 5 Next i := 1; k := 0; Next[1] := 0; WHILE i < SLength DO WHILE (k > 0) AND (String[i]#String[k]) DO k := Next[k] END; (* WHILE *) k := k + 1; i := i + 1; IF String[i] = String[k] THEN Next[i] := Next[k] ELSE Next[i] := k END; (* IF *) END; (* WHILE *) i : 8 k : 5 > 1 > 0

54 The KMP algorithm Building the Next function A T C A T C A C A T String 0 1 1 0 1 1 0 5 0 Next i := 1; k := 0; Next[1] := 0; WHILE i < SLength DO WHILE (k > 0) AND (String[i]#String[k]) DO k := Next[k] END; (* WHILE *) k := k + 1; i := i + 1; IF String[i] = String[k] THEN Next[i] := Next[k] ELSE Next[i] := k END; (* IF *) END; (* WHILE *) i : 8 > 9 k : 0 > 1

55 The KMP algorithm Building the Next function A T C A T C A C A T String 0 1 1 0 1 1 0 5 0 Next i := 1; k := 0; Next[1] := 0; WHILE i < SLength DO WHILE (k > 0) AND (String[i]#String[k]) DO k := Next[k] END; (* WHILE *) k := k + 1; i := i + 1; IF String[i] = String[k] THEN Next[i] := Next[k] ELSE Next[i] := k END; (* IF *) END; (* WHILE *) i : 9 k : 1

56 The KMP algorithm Building the Next function A T C A T C A C A T String 0 1 1 0 1 1 0 5 0 1 Next i := 1; k := 0; Next[1] := 0; WHILE i < SLength DO WHILE (k > 0) AND (String[i]#String[k]) DO k := Next[k] END; (* WHILE *) k := k + 1; i := i + 1; IF String[i] = String[k] THEN Next[i] := Next[k] ELSE Next[i] := k END; (* IF *) END; (* WHILE *) i : 9 > 10 k : 1 > 2

57 Actual KMP search j := 1; i := 1; WHILE (i <= SLength) AND (j <= TLength) DO WHILE (i > 0) AND (Text[j] # String[i]) DO i := Next[i] END; (* WHILE *) i := i + 1; j := j + 1; END; (* WHILE *) IF i > SLength THEN RETURN j - SLength ELSE RETURN TLength END; (* IF *)

58 String Search Performance Text length = n characters String length = m characters The Algorithms: –Brute Force Worst case search time : O(n*m) –Knuth, Morris & Pratt (KMP - 1974) Worst case search time : O(n+m) –Boyer & Moore (BM - 1977) Similar to but slightly better than KMP.


Download ppt "Chapter 2.8 Search Algorithms. Array Search –An array contains a certain number of records –Each record is identified by a certain key –One searches the."

Similar presentations


Ads by Google