Representing and Searching Sets of Strings

Size: px

Start display at page:

Download "Representing and Searching Sets of Strings"

Brianna Shaw
5 years ago
Views:

1 Representing and Searching Sets of Strings Antonio Carzaniga Faculty of Informatics University of Lugano December 1, 2006

2 Outline Radix search Ternary search tries

3 Why Sets of Strings?

4 Why Sets of Strings? Several very important applications

5 Why Sets of Strings? Several very important applications E.g., dictionary symbol table in a compiler all kinds of key-based index...

6 Symbol Table Operations

7 Symbol Table Operations insert(key) delete(key) search(key) min() max()

8 Dictionary Operations

9 Dictionary Operations insert(key) search(key)

10 Dictionary Operations insert(key) search(key) No delete operation Built once and searched many times

11 Binary Search BINARYSEARCH(A, k) 1 first 1 2 last length(a) 3 while first last 4 do m (first + last)/2 5 if A[m] = k 6 then return TRUE 7 elseif first = last 8 then return FALSE 9 elseif A[m] > k 10 then last m 1 11 else fisrt m return FALSE TREE-SEARCH(T, k) 1 x root(t) 2 while x = NIL k = key(x) 3 do if k < key(x) 4 then x left(x) 5 else x right(x) 6 if x = NIL 7 then return TRUE 8 else return FALSE

12 Binary Search BINARYSEARCH(A, k) 1 first 1 2 last length(a) 3 while first last 4 do m (first + last)/2 5 if A[m] = k 6 then return TRUE 7 elseif first = last 8 then return FALSE 9 elseif A[m] > k 10 then last m 1 11 else fisrt m return FALSE TREE-SEARCH(T, k) 1 x root(t) 2 while x = NIL k = key(x) 3 do if k < key(x) 4 then x left(x) 5 else x right(x) 6 if x = NIL 7 then return TRUE 8 else return FALSE Complexity?

13 Binary Search BINARYSEARCH(A, k) 1 first 1 2 last length(a) 3 while first last 4 do m (first + last)/2 5 if A[m] = k 6 then return TRUE 7 elseif first = last 8 then return FALSE 9 elseif A[m] > k 10 then last m 1 11 else fisrt m return FALSE TREE-SEARCH(T, k) 1 x root(t) 2 while x = NIL k = key(x) 3 do if k < key(x) 4 then x left(x) 5 else x right(x) 6 if x = NIL 7 then return TRUE 8 else return FALSE Complexity? we must account for the complexity of string comparisons

14 String Comparison

15 String Comparison Assuming a string is an array of bytes, A[m] = K becomes STRINGEQUALS(S 1, S 2 ) 1 if length(s 1 ) = length(s 2 ) 2 then return FALSE 3 for i 0 to length(s 1 ) 4 do if S 1 [i] = S 2 [i] 5 then return FALSE 6 return TRUE

16 String Comparison Assuming a string is an array of bytes, A[m] = K becomes STRINGEQUALS(S 1, S 2 ) 1 if length(s 1 ) = length(s 2 ) 2 then return FALSE 3 for i 0 to length(s 1 ) 4 do if S 1 [i] = S 2 [i] 5 then return FALSE 6 return TRUE The complexity of STRINGEQUALS(S 1, S 2 ) is O(M), where M is the max string size

17 String Comparison Assuming a string is an array of bytes, A[m] = K becomes STRINGEQUALS(S 1, S 2 ) 1 if length(s 1 ) = length(s 2 ) 2 then return FALSE 3 for i 0 to length(s 1 ) 4 do if S 1 [i] = S 2 [i] 5 then return FALSE 6 return TRUE The complexity of STRINGEQUALS(S 1, S 2 ) is O(M), where M is the max string size So, the complexity of BINARYSEARCH(A, K) is O(M lg N)

18 What About a Hash Table CHAINED-HASH-SEARCH(T, k) 1 L T[h(k)] 2 return LIST-SEARCH(L, k) HASH-SEARCH(T, k) 1 for i 1 to length(t) 2 do j h(k, i) 3 if T[j] = k 4 then return TRUE 5 if T[j] = NIL 6 then return FALSE 7 return FALSE

19 What About a Hash Table CHAINED-HASH-SEARCH(T, k) 1 L T[h(k)] 2 return LIST-SEARCH(L, k) HASH-SEARCH(T, k) 1 for i 1 to length(t) 2 do j h(k, i) 3 if T[j] = k 4 then return TRUE 5 if T[j] = NIL 6 then return FALSE 7 return FALSE Complexity?

20 What About a Hash Table CHAINED-HASH-SEARCH(T, k) 1 L T[h(k)] 2 return LIST-SEARCH(L, k) HASH-SEARCH(T, k) 1 for i 1 to length(t) 2 do j h(k, i) 3 if T[j] = k 4 then return TRUE 5 if T[j] = NIL 6 then return FALSE 7 return FALSE Complexity? here, too, we must account for the string comparisons

21 What About a Hash Table CHAINED-HASH-SEARCH(T, k) 1 L T[h(k)] 2 return LIST-SEARCH(L, k) HASH-SEARCH(T, k) 1 for i 1 to length(t) 2 do j h(k, i) 3 if T[j] = k 4 then return TRUE 5 if T[j] = NIL 6 then return FALSE 7 return FALSE Complexity? here, too, we must account for the string comparisons and for the hash functions

22 Observation

23 Observation When we start BINARYSEARCH(A, K) A[m] is probably far away from K so, STRINGEQUALS(A[m], K) is likely to return quickly

24 Observation When we start BINARYSEARCH(A, K) A[m] is probably far away from K so, STRINGEQUALS(A[m], K) is likely to return quickly Later in BINARYSEARCH(A, K) A[m] gets closer and closer to K so, STRINGEQUALS(A[m], K) is likely to iterate for nearly M steps

25 Observation When we start BINARYSEARCH(A, K) A[m] is probably far away from K so, STRINGEQUALS(A[m], K) is likely to return quickly Later in BINARYSEARCH(A, K) A[m] gets closer and closer to K so, STRINGEQUALS(A[m], K) is likely to iterate for nearly M steps problem is STRINGEQUALS(A[m], K) is likely to go through the same prefix of K many times

26 A New Data Structure Idea: a data structure where common prefixes are shared

27 A New Data Structure Idea: a data structure where common prefixes are shared a l g o c c i a i a o / c l a s s l u g a n o n a t i c

28 A Trie Data structure useful for information retrieval (pronounced try to distinguish it from a tree... )

29 A Trie Data structure useful for information retrieval (pronounced try to distinguish it from a tree... ) Every node holds one character

30 A Trie Data structure useful for information retrieval (pronounced try to distinguish it from a tree... ) Every node holds one character Keys with a common prefix share a branch representing that prefix

31 A Trie Data structure useful for information retrieval (pronounced try to distinguish it from a tree... ) Every node holds one character Keys with a common prefix share a branch representing that prefix Keys are stored at (or just represented by) leaf nodes

32 A Trie Data structure useful for information retrieval (pronounced try to distinguish it from a tree... ) Every node holds one character Keys with a common prefix share a branch representing that prefix Keys are stored at (or just represented by) leaf nodes Question is: how do we represent nodes and links? one way would be to hold Σ = 256 links one for each character of the given alphabet Σ

33 Radix Search Every element x has an array of links links(x) e.g., in radix-256, an element represents a byte in a string (of bytes) Every element x has a value(x) that is TRUE if that prefix corresponds to a string in the dictionary this is to distinguish an entire word from a prefix

34 Every element x has an array of links links(x) Radix Search e.g., in radix-256, an element represents a byte in a string (of bytes) Every element x has a value(x) that is TRUE if that prefix corresponds to a string in the dictionary this is to distinguish an entire word from a prefix RADIXSEARCH(Root, K) 1 n Root 2 for i 1 to length(k) 3 do if links(n)[k[i]] = NIL 4 then return FALSE 5 else n = links(n)[k[i]] 6 return value

35 Complexities of Radix Search What is the complexity of Radix Search with a dictionary of N strings of up to M characters?

36 Complexities of Radix Search What is the complexity of Radix Search with a dictionary of N strings of up to M characters? T(N, M) = Θ(M)

37 Complexities of Radix Search What is the complexity of Radix Search with a dictionary of N strings of up to M characters? T(N, M) = Θ(M) What is the space complexity?

38 Complexities of Radix Search What is the complexity of Radix Search with a dictionary of N strings of up to M characters? T(N, M) = Θ(M) What is the space complexity? S(N, M) = Θ(min( Σ MN, Σ M+2 ))

39 Idea We do not represent a full array of links

40 Idea We do not represent a full array of links Instead, we represent a small binary index of the existing links

41 Idea We do not represent a full array of links Instead, we represent a small binary index of the existing links E.g., prefixes xa, xb, xn, xk, and xs might be represented as follows a b + k x n + s

42 Idea We do not represent a full array of links Instead, we represent a small binary index of the existing links E.g., prefixes xa, xb, xn, xk, and xs might be represented as follows b a next character link next character index + k x n + s

43 Ternary Search Trie

44 Ternary Search Trie Every node n represent a byte character(n)

45 Ternary Search Trie Every node n represent a byte character(n) Every node n has three links lower(n) links to a node representing a lower character at the same position higher(n) links to a node representing a higher character at the same position equal(n) links to a node representing a character in the next position

46 Ternary Search Trie Every node n represent a byte character(n) Every node n has three links lower(n) links to a node representing a lower character at the same position higher(n) links to a node representing a higher character at the same position equal(n) links to a node representing a character in the next position A TST consists of a root node R

47 TST Search A recursive search where N is the current node, K is the key, and p is the current position within K TSTSEARCH(N, K, p) 1 if N = NIL 2 then return FALSE 3 elseif K[p] = 0 4 then return TRUE 5 elseif K[p] < character(n) 6 then return TSTSEARCH(lower(N), K, p) 7 elseif K[p] > character(n) 8 then return TSTSEARCH(higher(N), K, p) 9 elseif K[p] = character(n) 10 then return TSTSEARCH(equal(N), K, p + 1) The search starts with the root node TSTSEARCH(R, K, 0)

48 TST Insertion

49 TST Insertion Same recursive pattern where N is the current node, K is the key, and p is the current position within K TSTINSERT(N, K, p) 1 if N = NULL 2 then N NEWNODE(K[p]) 3 if K[p] = 0 4 then return N 5 elseif K[p] < character(n) 6 then lower(n) TSTINSERT(lower(N), K, p) 7 elseif K[p] > character(n) 8 then higher(n) TSTINSERT(higher(N), K, p) 9 elseif K[p] = character(n) 10 then equal(n) TSTINSERT(equal(N), K, p + 1) 11 return N The insertion starts with the root node R TSTINSERT(R, K, 0)

Elementary Data Structures and Hash Tables

Elementary Data Structures and Hash Tables Antonio Carzaniga Faculty of Informatics University of Lugano November 24, 2006 Outline Common concepts and notation Stacks Queues Linked lists Trees Direct-access