Backup Slides. An Example of Hash Function Implementation struct MyStruct { string str; string item;...
-
Upload
travon-gerrard -
Category
Documents
-
view
234 -
download
0
Transcript of Backup Slides. An Example of Hash Function Implementation struct MyStruct { string str; string item;...
Backup Slides
An Example of Hash Function Implementation
struct MyStruct {string str;string item;
};
---------------------------------------------------------// The hash function takes key “obj.str” to index of bucketint hash( const MyStruct & obj ){
int product = 1; int modulus = 0;for ( int i = 0; i < 3 && i < int( obj.str.length( ) ); i++ )
product *= (obj.str[ i ]-64); modulus = product % SIZE1;return modulus;
}
3
Uniform Hashing
When the elements are spread evenly (or near evenly) among the indexes of a hash table, it is called uniform hashing
If elements are spread evenly, such that the number of elements at an index is less than some small constant, uniform hashing allows a search to be done in ( 1 ) time
The hash function largely determines whether or not we will have uniform hashing
4
Bad Hash Functions
h( k ) = 5 is obviously a bad hash function h( k ) = k % 100 could be a bad hash function if
there is meaning attached to parts of a key Consider that the key might be an employee id The last two digits may give the state of birth
5
Ideal Hash Function for Uniform Hashing
The hash table size should be a prime number that is not too close to a power of 2
31 is a prime number but is too close to a power of 2
97 is a prime number not too close to a power of 2
A good hash function might be:h( k ) = k % 97
6
Hash Functions Can be Made for Keys that are Strings
1 int sum = 0;2 for ( int i = 0; i < int( str.length( ) ); i++ ) 3 sum += str[ i ];4 hash_index = sum % 97;
7
Speed vs. Memory Conservation
Speed comes from reducing the number of collisions In a search, if there are no collisions, the first
element in the linked list in the one we want to find (fast)
Therefore, the greatest speed comes about by making a hash table much larger than the number of keys (but there will still be an occasional collision)
8
Speed vs. Memory Conservation
(cont.)
Each empty LinkedList object in a hash table wastes 8 bytes of memory (4 bytes for the start pointer and 4 bytes for the current pointer)
The best memory conservation comes from trying to reduce the number of empty LinkedList objects
The hash table size would be made much smaller than the number of keys (there would still be an occasional empty linked list)
9
Hash Table Design
Decide whether speed or memory conservation is more important (and how much more important) for the application
Come up with a good table size which Allows for the use of a good hash function Strikes the appropriate balance between speed and
memory conservation
10
Ideal Hash Tables Can we have a hash function which guarantees that
there will be no collisions? Yes:
h( k ) = k Each key k is unique; therefore, each index produced
from h( k ) is unique Consider 300 employees that have a 4 digit id A hash table size of 10000 with the hash function
above guarantees the best possible speed
11
Ideal Hash Tables (cont.)
Should we use LinkedList objects if there are no collisions? Suppose each Employee object takes up 100 bytes An array size of 10000 Employee objects with only 300 used
indexes will have 9700 unused indexes, each taking up 100 bytes
Best to use LinkedList objects (in this case) – the 9700 unused indexes will only use 8 bytes each
Additional space can be saved by not storing the employee id in the object (if no collisions)
12
Ideal Hash Tables (cont.)
Can we have a hash table without any collisions and without any empty linked lists?
Sometimes. Consider 300 employees with id’s from 0 to 299. We can make a hash table size of 300, and use h( k ) = k
LinkedList objects wouldn’t be necessary and in fact, would waste space
It would also not be necessary to store the employee id in the object
13
Implementing aHash Table
We’ll implement a HashTable with linked lists (chaining) without chaining, a hash table can become full
If the client has the ideal hash table mentioned on the previous slide, he/she would be better off to just use an Array for the hash table
14
Implementing a Hash Function
We shouldn’t write the hash function The client should write the hash function that
he/she would like to use Then, the client should pass the hash function
that he/she wrote as a parameter into the constructor of the HashTable class
This can be implemented with function pointers
15
Function Pointers
A function pointer is a pointer that holds the address of a function
The function can be called using the function pointer instead of the function name
16
Function Pointers (cont.)
Example of a function pointer declaration:
float (*funcptr) (string);
17
Function Pointers (cont.)
Example of a function pointer declaration:
float (*funcptr) (string);
funcptr is the name of the pointer; the name can be chosen like any other pointer name
18
Function Pointers (cont.)
Example of a function pointer declaration:
float (*funcptr) (string);
The parentheses are necessary.
19
Function Pointers (cont.)
Example of a function pointer declaration:
float (*funcptr) (string);
The return type of the function that funcptr can point to is given here (in this case, the return type is a float)
20
Function Pointers (cont.)
Example of a function pointer declaration:
float (*funcptr) (string);
The parameter list of a function that funcptr can point to is given here – in this case, there is only one parameter of string type.
21
Function Pointers (cont.)
Example of a function pointer declaration:
float (*funcptr) (string);
What would a function pointer declaration look like if the function it can point to has a void return type and accepts two integer parameters?
22
Function Pointers (cont.)
void (*fp) (int, int);
23
Function Pointers (cont.)
void (*fp) (int, int);
void foo( int a, int b ){
cout << “a is: “ << a << endl;cout << “b is: “ << b << endl;
}
A function that fp can point to
24
Assigning the Address of a Function
to a Function Pointer void (*fp) (int, int);
void foo( int a, int b ){
cout << “a is: “ << a << endl;cout << “b is: “ << b << endl;
}
fp = foo;The address of foo is assigned to fp like this
25
Calling a Function by Using a
Function Pointer
Once the address of foo has been assigned to fp, the foo function can be called using fp like this
void (*fp) (int, int);
void foo( int a, int b ){
cout << “a is: “ << a << endl;cout << “b is: “ << b << endl;
}
fp( 5, 10 );
26
Design of theHashTable Constructor
Once the client designs the hash function, the client passes the name of the hash function, as a parameter into the HashTable constructor
The HashTable constructor accepts the parameter using a function pointer in this parameter location
The address of the function is saved to a function pointer in the private section
Then, the hash table can call the hash function that the client made by using the function pointer
27
HashTable.h1 #include "LinkedList.h"2 #include "Array.h“34 template <class DataType>5 class HashTable 6 {7 public:8 HashTable( int (*hf)(const DataType &), int s );9 bool insert( const DataType & newObject ); 10 bool retrieve( DataType & retrieved ); 11 bool remove( DataType & removed ); 12 bool update( DataType & updateObject ); 13 void makeEmpty( ); HashTable.h continued…
28
HashTable.h
14 private:15 Array< LinkedList<DataType> > table;16 int (*hashfunc)(const DataType &); 17 };1819 #include "HashTable.cpp"
Space is necessary here
29
Clientele
The LinkedList class is being used in the HashTable class, along with the Array class
Note that when one writes a class the clientele extends beyond the main programmers who might use the class
The clientele extends to people who write other classes
30
HashTable Constructor
1 template <class DataType>2 HashTable<DataType>::HashTable( 3 int (*hf)(const DataType &), int s )4 : table( s )5 {6 hashfunc = hf;7 }
This call to the Array constructor creates an Array of LinkedList’s of type DataType
31
HashTable Constructor(cont.)
1 template <class DataType>2 HashTable<DataType>::HashTable( 3 int (*hf)(const DataType &), int s )4 : table( s )5 {6 hashfunc = hf;7 }
The DataType for Array is LinkedList<DataType> (DataType in Array is different than DataType in HashTable)
32
HashTable Constructor(cont.)
1 template <class DataType>2 HashTable<DataType>::HashTable( 3 int (*hf)(const DataType &), int s )4 : table( s )5 {6 hashfunc = hf;7 }
In the Array constructor, an Array of size s is made, having LinkedList elements – when this array is created, the LinkedList constructor is called for each element.
33
HashTable Constructor(cont.)
1 template <class DataType>2 HashTable<DataType>::HashTable( 3 int (*hf)(const DataType &), int s )4 : table( s )5 {6 hashfunc = hf;7 }
34
insert
8 template <class DataType>89 bool HashTable<DataType>::insert( 10 const DataType & newObject )11 {12 int location = hashfunc( newObject );13 if ( location < 0 || location >= table.length( ) )14 return false;15 table[ location ].insert( newObject ); 16 return true;17 } Keep in mind that this is a
LinkedList object.
35
retrieve18 template <class DataType>19 bool HashTable<DataType>::retrieve( 20 DataType & retrieved )21 {22 int location = hashfunc( retrieved );23 if ( location < 0 || location >= table.length( ) )24 return false;25 if ( !table[ location ].retrieve( retrieved ) )26 return false;27 return true;28 }
36
remove29 template <class DataType>30 bool HashTable<DataType>::remove( 31 DataType & removed )32 {33 int location = hashfunc( removed );34 if ( location < 0 || location >= table.length( ) )35 return false;36 if ( !table[ location ].remove( removed ) )37 return false;38 return true;39 }
37
update40 template <class DataType>41 bool HashTable<DataType>::update( 42 DataType & updateObject )43 {44 int location = hashfunc( updateObject );45 if ( location < 0 || location >= table.length( ) )46 return false;47 if ( !table[location].find( updateObject ) )48 return false;49 table[location].replace( updateObject );50 return true;51 }
38
makeEmpty
50 template <class DataType>51 void HashTable<DataType>::makeEmpty( )52 {53 for ( int i = 0; i < table.length( ); i++ )54 table[ i ].makeEmpty( );55 }
39
Using HashTable
1 #include <iostream>2 #include <string>3 #include "HashTable.h"45 using namespace std;67 struct MyStruct {8 string str;9 int num;10 bool operator ==( const MyStruct & r ) { return str == r.str; }11 };
str will be the key
40
Using HashTable(cont.)
1 #include <iostream>2 #include <string>3 #include "HashTable.h"45 using namespace std;67 struct MyStruct {8 string str;9 int num;10 bool operator ==( const MyStruct & r ) { return str == r.str; }11 };
It is necessary to overload the == operator for the LinkedList functions
41
Using HashTable(cont.)
1 #include <iostream>2 #include <string>3 #include "HashTable.h"45 using namespace std;67 struct MyStruct {8 string str;9 int num;10 bool operator ==( const MyStruct & r ) { return str == r.str; }11 };
In the actual code, a comment is placed above HashTable, telling the client that this is needed and what is required.
42
Using HashTable(cont.)
12 const int SIZE1 = 97, SIZE2 = 199;1314 int hash1( const MyStruct & obj );15 int hash2( const MyStruct & obj );1617 int main( )18 {19 HashTable<MyStruct> ht1( hash1, SIZE1 ), 20 ht2( hash2, SIZE2);
43
Using HashTable(cont.)
21 MyStruct myobj;2223 myobj.str = "elephant";24 myobj.num = 25;25 ht1.insert( myobj );2627 myobj.str = "giraffe";28 myobj.num = 50;29 ht2.insert( myobj );
…// other code using the hash tables…
44
Using HashTable(cont.)
30 return 0;31 }3233 int hash1( const MyStruct & obj )34 {35 int sum = 0;36 for ( int i = 0; i < 3 && i < int( obj.str.length( ) ); i++ )37 sum += obj.str[ i ];38 return sum % SIZE1;39 }