Design a Data Structure Suppose you wanted to build a web search engine, a la Alta Vista (so you can search for “banana slugs” or “zyzzyvas”) index say 100,000,000 documents of 1000 words each  100 billion word occurrences. average word length: 8 speed determined largely by disk accesses may want boolean searches (e.g. “banana” and “slug”) order results by relevance (title, keywords, repetitions…) what data structure, algorithms? what will the space requirements of your data structure be? what will the time requirements be?

Search Engine Ideas Binary search tree With a node for each word occurrence, memory needed: 100 billion nodes, bytes each? Insert, delete, find O(log n) – would that be OK? Or one node for all occurrences of a word, with a linked list of pointers to documents? perhaps 10 million nodes, each with a 10,000 element list? keep nodes (but not lists) in RAM each element of list has URL, title, excerpt – 8K bytes? How about a list of documents with excerpts. 1. Banana Slugs, “Banana slugs are yellow, 8” long…” 8K per document would be 800 GB for the whole list.

Getting results What should we store at the nodes of the BST? A “hit list” for a word? entries? Store a pointer to a hit list instead, to minimize BST size For each hit store document number and byte offset Order hit list by relevance criteria Size of hit list: 8GB? How many disk accesses to find the hits in a BST? At 100 million * bytes per node, the BST is large. Can we store it all in RAM? How to perform a Boolean search? or: union two lists (merge) and: intersect two lists (merge-like algorithm) Total disk accesses needed? search BST + access hit list + access each document’s info

A Better Data Structure BSTs waste space. Much duplication in the keys BSTs waste comparison time, for the same reason Can we use the ideas of Radix Sort? Search by bit? or by letter? Build a search tree, but… Go left if first bit is 0, right for 1 Or, nodes have 26 children, for a..z Words at the leaves. (Different sort of node.) Each leaf node is a “hit list” Don’t need to store the words! How much space is needed? suppose you have all 11.9M 5-letter words. space for tree about 1 pointer per word, 4 bytes, vs. 20(?) in BST Space savings possible--but what about wasted pointer space?

Radix Search (Ch. 15) Radix-search methods provide reasonable worst-case performance without balanced-tree complexity Space savings are also possible. They work by comparing pieces (“bytes”) of the key rather than the whole key, as in a BST Analogous to Radix Sorting methods Called “tries” for retrieval (but, ironically, pronounced like the word tries)

Symbol Tables (Ch. 12 quickie) But first, a word about symbol tables and BSTs (review) Symbol table: store items. retrieve them by key. e.g. a compiler’s symbol table e.g. a database with primary key e.g. Perl’s hash data structure (essentially an array indexed by a word.) $phone{“john”} = “x6789”. fundamental to much of computation Symbol table ADT (with additional desirable ops): insert, delete, find select (kth largest) sort union (of two symbol tables) Extensively studied and still an area of active research(eg web)

BSTs for Symbol Tables The Binary Search Tree is a common data structure used to implement symbol tables Operations: insert, delete, find – recursive algs, O(n) worst case O(log n) worst case in balanced BSTs sort – inorder traversal O(n) kth largest? augment tree with number of descendants stored at each node O(log n) time in a balanced BST pred, succ? union?

Digital Search Trees (Ch. 15 again) Like a BST, but go left for 0, right for 1 in the bit in question Store key at node Root is most significant bit; ith level -> ith bit from left Search: like BST search, but compare appropriate bit Insert: ditto Note: not inorder! Each key is somewhere along the path specified by its bits… Can’t support sort, select Search time? O(b), b=# of bits

Digital Search Tree Insertion How to insert Z? Z=11010 Trace down bits until you find an empty spot Runtime? O(b), b=number of bits

Trie How can we keep the BST order? Trie: a binary tree with keys at the leaves: for an empty set is a null pointer for a single key a leaf containing it for many keys, a node with keys starting with bit 0 in its left subtree and nodes starting with 1 in its right subtree

Trie Insertion Perform search as usual. If search ends at null link, insert there If the search ends on a leaf, we need to add enough nodes on the way down to differentiate the leaf and the inserted node Runtime? O(b) -- or maybe better! Inserting N random bitstrings requires lg N bit comparisons on average per insertion Note that leaf nodes and internal nodes are different. Wasted space if we use only one sort. (This gets especially significant in a large radix!) Even with different node types, there may be wasted space

R-way Tries You can save search time by using a larger radix (at the expense of wasted space…) For example, have 26 children of each node, one for each letter of the alphabet

Tries for strings 26 pointers per internal node, one for each letter of the alphabet What if one word is the prefix of another? Example aardvark and aardvarkish How do you represent that “aardvark” is a word if that node’s ‘i’ pointer points to another internal node? Add a bit per letter which means “this is a word” Keys are stored implicitly – by the sequence of links taken to find it.

A Trie node for strings struct node { char isword[26]; node *links[26]; node() { for (int i=0; i<26; i++) { isword[i]=0; links[i]=0; } } }; But where is the word stored?

Insertion How do you insert a string into a trie? void insert(string word, node *n, int pos) { if (pos == word.size() - 1) { n->isword[index(word[pos])] = 1; return; } if (n->links[index(word[pos])] == NULL) n->links[index(word[pos])] = new node; insert(word, n->links[index(word[pos])], pos+1); return; } int index(char ch) { return int(ch-’a’); }

Experimental Results In my implementation a node used 132 bytes words were read in nodes were allocated Total space 6,038,604 bytes (compared with 200k size of /usr/dict/words) Average word length 7.4 characters Average comparisons per search: 7.4 one-character comparisons (compared to 15 word comparisons for a balanced BST) Much easier to implement than a balanced BST

Using a Trie: Examples Spell checker: fast but big Symbol table with lots of short symbols Boggle-playing program read /usr/dict/words into a trie generate a 4x4 square of random letters DFS (or BFS) starting at each square, not re-using letters, finding all words from trie…