Source: Internet
Author: User

In this paper, two kinds of hashing are implemented--linear open addressable hashing, linked list hashing

Hash list-A dynamic collection structure that supports only the basic rules for Insert,search and delete operations: Keyword Key,index=fun (key), T[index] satellite data, function fun that is, hash function.

The expected time to find an element is O (1)

Direct addressing table: The keyword whole domain is relatively small, uses the array to store completely, corresponds each. Insert,search and delete operations are all O (1)

Hash list: The keyword is larger in whole domain and may collide.

How to solve the collision:

1 Find the appropriate hash function. The hash function is carefully selected, and the possible collisions are still resolved, and the method is not quite thorough.

2) Link method (Implementation)

Given a hash-list t that holds n elements and has m slots, defines the load factor a=n/m of T, that is, the average number of elements stored in a chain.

The probability of any element being hashed into an M slot is the same, and independent of where other elements have been hashed out.

This is called a simple consistent hash. A successful lookup is O (1+a), a=n/m, insert delete O (1), note A (in the book is Alpha)

3 Open addressing methods (for example, linear open-line addressable hashing)

All elements are stored in a hash table, no linked list (that is, no elements are stored outside the hash list), and the load factor is not greater than 1.

To insert an element, you can continuously examine the items in the hash table until you find an empty slot to place the keyword to be inserted.

Design hash function (algorithm design slightly)

Heuristic method: Multiplication Hash and division hash

Randomization method: Full-domain hashing

The realization of linear open addressable hashing

It is difficult to perform a delete operation on a hash table element, but it can be resolved by:

When removing slot I, set a specific value deleted in slot I instead of nil. Of course, the corresponding Hash-search and Hash-insert must cooperate with the modification.

The lookup time does not depend on Mount factor A. Therefore, in the application that must delete the keyword, the link method is often used to solve the collision.

The **following implementation of the deletion method, is written in the next write, is not correct. **

File hash.h #ifndef hashtable_ #define Hashtable_ #include <iostream> #include <stdlib.h> #include "xcept. H "using namespace std; Template<class E, Class k> class HashTable {public:hashtable (int divisor = 11); ~hashtable () {delete [] HT; delete [] empty;} BOOL Search (const k& K, e& E) const; hashtable<e,k>& Insert (const e& E); hashtable<e,k>& Delete (e& E); void output (),//Output the hash table Private:int hsearch (const k& K) const; int D; hash function divisor E *ht; Hash table array bool *empty; 1D array}; Template<class E, class k> hashtable<e,k>::hashtable (int divisor) {//constructor. D = divisor; Allocate hash table Arrays HT = new E [D]; empty = new bool [D]; Set all buckets to empty for (int i = 0; i < D; i++) empty[i] = true; Template<class E, class k> int Hashtable<e,k>::hseArch (const k& K) Const {//Search an open addressed table. Return location of K if present. Otherwise return inserts point if there are space. int i = k% D; Home bucket Int j = i; Start at home bucket do {if (Empty[j] | | | ht[j] = = k) return J; j = (j + 1)% D; Next Bucket} while (J!= i); Returned to home? Return J; Table Full} Template<class E, class k> bool Hashtable<e,k>::search (const k& K, e& e) const {//Pu t element that matches K in E. return False if no match. int B = Hsearch (k); if (Empty[b] | | | ht[b]!= k) return false; e = Ht[b]; return true; } template<class E, class k> hashtable<e,k>& hashtable<e,k>::insert (const E& E) {//Hash table Insert. K k = e; Extract key int b = Hsearch (k); Check if insert is to being done if (Empty[b]) {empty[b] = false; HT[B] = e; return *this;} No INSERT, check IF Duplicate or full if (ht[b] = k) throw badinput (); Duplicate throw Nomem (); Table Full} Template<class E, class k> hashtable<e,k>& hashtable<e,k>::D elete (e& E) {//has H table Insert. K k = e; Extract key int b = Hsearch (k); The check if insert is to being done if (Empty[b]) {cout << does not have this element. "<< Endl; return *this; } Empty[b] = true; int count = 0; int index = b+1; while (index!= b) {if (index >= d) Index-= D; K key; if (!empty[index]) {key = Ht[index]; if (key% D)!= index) count++; } index++; } cout << "count=" << count << Endl; E *temp = new E[count]; index = b+1; int i = 0; while (index!= b) {if (index >= d) Index-= D; K key; if (!empty[index] && i < count) {key = Ht[index]; if ((key% D)!= index) {temp[i] = Ht[index]; Empty[index] = true; i++; }} index++; for (i = 0;i < count;i++) Insert (Temp[i]); Delete[] temp; return *this; Template<class E, class k> void Hashtable<e,k>::output () {for (int i = 0; i< D; i++) {if (empt Y[i]) cout << "Empty" << Endl; else cout << Ht[i] << Endl;} } #endifXcept.h file

Hash.cpp Test ExampleException classes for various error types #ifndef xcept_ #define XCEPT_ #include <new> Itializers class Badinitializers {public : badinitializers () {} }; Insufficient memory class Nomem {public : Nomem () {} }; Change new to throw Nomem instead of xalloc void My_new_handler () {throw nomem (); New_handler old_handler_ = Set_new_handler (My_new_handler); Set_new_handler (My_new_handler); Improper array, find, insert, or delete index //or deletion from empty structure class Outofbounds { pu Blic: outofbounds () {} }; Use when operands should have matching the size class Sizemismatch {public : Sizemismatch () {} }; //use when zero is expected class Mustbezero {public : Mustbezero () {} }; Use when zero is expected class Badinput {public : badinput () {} }; #endif

Test hash table with linear open addressing #include <iostream> #include "hash.h" class element {friend int Main (void); Public:operator Long () const {return key;}//private:g++ has a problem with main a friend int data; Long key; }; int main (void) {hashtable<element, long> h (11); Element e; E.key = 80; H.insert (e); E.key = 40; H.insert (e); E.key = 65; H.insert (e); H.output (); E.key = 58; H.insert (e); E.key = 24; H.insert (e); cout << ' << Endl; H.output (); E.key = 2; H.insert (e); E.key = 13; H.insert (e); E.key = 46; H.insert (e); E.key = 16; H.insert (e); E.key = 7; H.insert (e); E.key = 21; H.insert (e); cout << ' << Endl; H.output (); E.key = 99; try {H.insert (e);} catch (Nomem) {cout << "No memory for" << Endl;} cout << "Delete" << Endl; E.key = 24; H.delete (e); H.output (); cout << "Delete 15,there is not the element" << Endl; E.key = 15; H.delete (e); H.output (); E.key = 2; H.delete (e); H.output (); return 0; }Makefile file

HASH:HASH.O hash.o xcept.h g++-o hash hash.o hash.o:hash.cpp hash.h xcept.h g++- c hash.cpp hash.h xcept.h g++-C hash.h g++-C xcept.h Clean : rm-f Hash *.O *.gch

Output results:

Empty empty empty empty empty empty -Empty empty Empty empty empty empty empty empty 7 2 memory No -for-delete count=7 empty 2 km/ 7 The delete 15,there is not the element does not have it. Empty 2/ 7 count=6 21 empty 7 empty 65

Link Method implementation

Related Article