Midterm 3 practice problems

Transcription

1 Midterm 3 practice problems CS 133 May 3, Hash functions and hash tables What are the two good hash methods we discussed, and how do they work? Remainder: use Horner s method to treat the string as a (big) base-256 number, and then take that modulo m, the hash-table size. Multiplicative: multiply the output of Horner s method by A, a floating-point constant, take the fractional part, multiply by m, and finally round down. What are the properties that a hash function should have? Deterministic Uniform distribution Avalanche Effect Low probability of collision Why is using string length, or the first character of a string, bad choices for hash functions? Because it will result in a lot of collisions and is highly non-uniform. All strings with the same first char, same length, will hash to the same value. Write the remainder hash function for strings, using a hash size of m. string s =...; int h = 0; for(int i = 0; i < s.length(); ++i) h = (256 * h + s[i]) % m; 1

2 Write the multiplicative hash function, using an arbitrary predefined constant A and a hash size of m. string s =...; float fh = 0; for(int i = 0; i < s.length(); ++i) fh = fmod(a * fh * A * s[i], 1); int h = int(fh * m); How does the collision resolution method chaining work? By storing a linked-list in each hash-table entry. Collisions result in new elements being added to the front of the list. How does the collision resolution method probing work, and what are the three probe sequences we discussed. By searching for another empty location in the table when a collision occurs. The three probe sequences are Linear: search the next location (i.e., probe sequence is hash(s) + i where i is incremented every time we hit a full location). Quadratic: search hash(s) + a i + b i for some constants a and b (not all constants work!). Double-hashing: use two hash functions to get hash (s) + hash (s) i. The best open addressing method. Assuming remainder hashing with m = 9, insert the following values into a hash table using chaining: 1 2, ,4, , 28, 38, 47, 83 2

3 Assuming remainder hashing with m = 9, insert the previous values into a hash table using open addressing, with linear probing What is the load factor α of the above table, after inserting the values? α = What is the problem with linear probing? It leads to clustering: groups of full table-entries. Any value that hashes into the cluster will have to search all the way to the end of the cluster to find an empty space (slow) and will also grow the cluster, making future collisions that much worse. 2 Parsing and expression trees Here is a grammar for arithmetic expressions with numeric constants, variables, and functions of the form f(e) where e is a subexpression: exp -> NUM exp -> VAR exp -> "-" exp exp -> exp OP exp exp -> "(" exp ")" exp -> FUNC "(" exp ")" Construct a derivation to show that the expression x + y * sin(1 + x) is valid according to this grammar. 3

4 exp / \ / \ / \ exp * exp / / \ / / \ exp * sin ( exp ) / \ / \ / \ / \ exp * exp * sin ( exp + exp ) x + y * sin ( 1 + x ) (Ugly, sorry.) Write a set of expression tree structs for the above class of expressions. struct exp {; // Base class struct exp_num : public exp { int value; ; struct exp_var : public exp { string name; ; struct exp_minus : public exp { exp* inner; ; struct exp_op : public exp { char op; exp* l; exp* r; ; struct exp_fn : public exp { string name; exp* arg; ; //Optional: struct exp_paren : public exp { exp* inner; ; Here is a grammar for monoids, an algebraic structure that is equivalent to arithmetic if all we had was + (technically, we also need 0, the identity element). mon -> NUM mon -> mon "+" mon mon -> "(" mon ")" Write a validator bool is_mon(tokens, start, finish) over a token sequence to return true if the portion between [start, finish] is a valid sequence in this language. You can use the function is_num to test whether a string looks like a numeric token. using vector<string>iterator; bool is_mon(it start, it finish) { 4

5 using vector<string>iterator; bool is_mon(it start, it finish) { if(start finish) return false; else if(finish - start 1) return is_num(*start); else { if(*start "(" && *(finish-1) ")" && is_mon(start+1, finish-1)) return true; for(it p = start+1; p < finish-1; ++p) if(*p "+" && is_mon(start,p) && is_mon(p+1, finish)) return true; return false; Here is a tree class for the above grammar: struct monoid { virtual void print() = 0; virtual int eval() = 0; ; struct mon_num { virtual void print(); virtual void eval(); ; int value; struct mon_plus { virtual void print(); virtual void eval(); ; monoid* left; monoid* right; Implement the virtual method print for the mon_num and mon_plus to print out a monoid structure in infix notation. void mon_numprint() { 5

6 cout << value; void mon_plusprint() { left->print(); cout << "+"; right->print(); Implement the eval() method which should return the value of a monoid expression. int mon_numeval() { return value; int mon_pluseval() { return left->eval() + right->eval(); 6