Hashtable
 Hash table  hash table
 Hash table is a very important data structure. Almost all programming languages use or indirectly use hash table
 Its structure is an array, but its difference from the array is the transformation of the subscript value, which is called the hash function, and the HashCode is obtained through the hash function
 Hash table is usually implemented based on array, but it has many advantages over array
 It allows very fast insert delete find operations
 No matter how much data, the insertion and deletion of values need to be close to a constant time: that is, the time level of O (1). In fact, it only needs a few machine instructions to complete
 The speed of hash table is faster than that of tree. It can basically find the desired elements in an instant
 Hash table coding is much easier than tree coding
 Hash tables have some disadvantages over arrays
 The data in the hash table is out of order, so the elements in the hash table cannot be traversed in a conventional way
 Generally, the key value in the hash table is not allowed to be null, and the same key cannot be placed to save different elements
structure
When we store a value (number, character, bool, etc.) into the hash table, the hash function encodes the data into a large integer, compresses the large integer, obtains the subscript value of the data in the array structure through hashing, and then directly stores the value in the corresponding array position, and then queries and modifies it, For deletion, only the subscript obtained by hashing the query value directly goes to the corresponding subscript position to get the data. There is no need to traverse, and the efficiency will be much higher.
hash function
Convert words or other data into large numbers. The code implementation of hashing large numbers is put in a function, which is called hash function
Character to integer

Word / string to subscript value is actually letter / text to number
 Now we need to design a scheme that can turn words into appropriate subscripts
 In fact, there are many coding schemes in the computer, that is, to replace the characters of words with numbers
 Such as character encoding·
 ASCII coding, but also to their own design coding
 We can use Utf  8 coding
 Now we need to design a scheme that can turn words into appropriate subscripts

How to turn?

Digital addition scheme

Use the position of words in the word list

For example, cats = 3 + 1 + 20 + 17 = 41; When querying the hash table, you only need to query the subscript 41 to find the word cats

Disadvantages: not complex enough and easy to repeat


Power multiplication scheme

It can basically meet the uniqueness of numbers and will not be repeated with other words

E.g. 7654 = 710 ³ + six hundred and ten ² + 5*10 + 4；

Then the word can also be expressed as cats = 327 ³ + one hundred and twentyseven ² + 20*27 + 17 = 60337

At this time, 60337 is the subscript of the word cats in the hash table. When querying the hash table, you only need to query the subscript 60337 to find the word cats

shortcoming

Creating meaningless words, such as yyyyyyyy, wastes space, and the array cannot represent such a large subscript value

When we get a large value, the general size will be very large. If we create an array of corresponding length, it will be a waste of space. At this time, we need to carry out certain compression operations to control the data within an acceptable range.
Hashing
 Hashing
 Now we need a compression method to compress the huge integer range obtained by concatenation to an acceptable range, so as to avoid that the array cannot represent such a large subscript range
 Generally, a lot of space is required to store data, because it is not guaranteed that each data can be fully mapped to each position of the array (some positions do not necessarily have only one data)
 compress
 Now compress the excessive power multiplication data to an acceptable range
 Operation: residual
 Gets the remainder of a number divided by another number
 Suppose we want to compress the maximum value of 10000 to the maximum value of 100
 We first set a hash table subscript value index = 10000 / 100 = 100;
 When there is a data 23459, it will be stored in the hash table in the range of (23459% index) = 9, and the value of 120 will be stored in (120% index = 0)
This range is in the hash table.  There will also be duplication
 concept
 Hashing: the process of converting large numbers into subscripts within the array range is called hashing.
 Hash function: convert words or other data into large numbers. The code implementation of hashing large numbers is put in a function. This function is called hash function, such as the previous one (10000% 100)
 Hash table: finally, the data is inserted into this array to encapsulate the whole structure, which is called hash table
After the data is converted into large numbers by power multiplication, it is impossible to directly open the space of the corresponding size on the array (waste space, some space is not used). At this time, the number obtained after hashing can be used as a subscript and put the value into the array of the corresponding subscript. For example, there is an array with a length of 8 (the size of the corresponding hashed remainder is 9), The number 23344 corresponds to the position of subscript 4, and the number 125 corresponds to the position of subscript 5····
Hash Collisions
We found that the index values obtained by hashing the stored values may be repeated (although this possibility is not high), but once a hash conflict occurs, the previous data will be overwritten by the subsequent data. In this case, it is necessary to solve the hash conflict
When multiple data appear at the same subscript position, data may be inserted at this time, which may lead to previous data loss
The common solutions are chain address method and open address method
Chain address method

By using a linked list or array to store data at the subscript position, multiple data can be stored at one subscript position. When querying, you can query according to the query method of linked list or array

When a linked list is used, data is usually inserted from the head or tail. If an array is used, it is usually inserted from the tail for performance priority
When there is a conflict. The inserted data will be filled into the array or linked list to avoid data loss.
Open address method
It is mainly to find a blank location to add data, but there are three methods to find this location
Linear detection

When there is data in the current location, the location will be searched from the next location. When an empty location is found, the data will be inserted

When searching this data, first query whether the current location data is the same as the query data. If it is the same, this value will be returned. If it is different, continue to search the query value from the next location. When a blank location is encountered, terminate the query. (because the value (duplicate) will only be placed in the first blank position. If a null value is found and the value is still not found, it is impossible to have the value later. Terminate the query to avoid affecting performance).

When a value is deleted, the current position should specify a special value (such as  1). When the query data encounters this value ( 1), continue to query backward to avoid affecting the query of subsequent data due to the null value after deleting the data in the specified position (interrupting the query).
Secondary detection
Problems with linear queries,
 When there is no data, when we insert a piece of data gathered in a certain position, it will affect the performance of hash table query. When we query a piece of data, and its original position is occupied by other elements, and there are many other continuous data in its lower position, if we want to query it, we must query the data in this area again and again, Until the element inserted in other areas is queried
gather
 Secondary detection to solve the aggregation problem
Secondary detection is mainly to solve the problem of step size of linear detection. Ordinary linear detection can be regarded as detection with step size of 1, and secondary detection can be regarded as detection across multiple columns, such as span (x is the subscript value) x+1, x+2 ²··· (if the following scale value is 2, then the steps are (3,6,10)) this can detect a long distance at one time and avoid the impact of aggregation
double hashing
Problems in secondary detection when we insert the value of the same subscript (1210211222 ·); At this time, if the step size of the secondary detection is the same, there will also be a performance problem. This problem can be solved by hashing it again
Efficiency of hashing
Efficiency of hashing
 If there is no conflict, the efficiency will be higher  If a conflict occurs, the access time depends on the subsequent probe length(That is, the amount of data in the linked list or array corresponding to each subscript of the array).  Average probe length and average access time, depending on`Load Factor `，As the loading factor increases, the length of detection becomes longer and longer.
 Load Factor
 The loading factor represents the ratio of the data items already contained in the current hash table to the length of the entire hash table.
 Loading factor = total data item / hash table length
 The loading factor of open address method is up to 1, because it must find a blank cell to put elements into
 The filling factor of the chain address method can be greater than 1, because the zipper method can extend indefinitely
In theory, the open address method is much more efficient.
Generally, when the data item has occupied half of the length of the hash table, the hash expansion should be considered.
Horner's rule in hashing (Qin Jiushao algorithm)
Apply to hash function
 Pn(x) = anx^n + a(n1)x^(n1)+···+ a1x + a0 = ((···(((anx + an  1)x + an  2)x + an 3)···)x+a1)x + a0
Implement hash table (chain address method to solve hash conflict [use array])
Encapsulate a hash function
// Encapsulate a hash function // Converts a string to a larger number hashCode // Compress larger numbers into the range of the array (hash table length) // Returns the location of the stored subscript value function hashFunc(str, size): number { // Define hashcode variables let hashCode: number = null; // The hashcode value is calculated by Qin Jiushao algorithm // Convert str to unicode encoding for (let i = 0; i < str.length; i++) { hashCode = 37 * hashCode + str.charCodeAt(i); } // Surplus let index: number = hashCode % size; //Return subscript position return index; }
Where str is the stored data  which will be converted to large numbers
size is the length of the designed hash table (the remainder of large numbers is used to compress large numbers)
index returns the subscript position in the array
Encapsulate hash table
// Encapsulate hash table class MyHashTable { // Hashtable private message: unknown[] = []; // The number of elements already stored in the hash table private count: number = 0; // Length of hash table (length of compressed array) private limit: number = 10; // hash function private runHashFunc(str: unknown, size: number): number { return hashFunc(str, size); } // Hash table insertion and modification methods alter(key: unknown, value: number): boolean { let index: number; // Get the corresponding index (subscript position) according to the key (hashed) index = this.runHashFunc(key, this.limit); // Gets the array corresponding to the subscript position let bunck: unknown = this.message[index]; // When there is no array at the corresponding subscript position, create an array and place it at the corresponding subscript position if (bunck === undefined) { bunck = []; this.message[index] = bunck; } // In case of modification for (let i = 0; i < bunck.length; i++) { // Find the key of the qualified array group corresponding to the subscript and modify the key if (bunck[i][0] === key) { bunck[i][1] = key; return true; } } //Insert operation bunck.push([key, value]); this.count += 1; return true; } // Acquisition method getNode(key: unknown): unknown { // To get the index, you need to use the hash function let index: number = this.runHashFunc(key, this.limit); // Find the array corresponding to the subscript let bunck: unknown[] = this.message[index]; // Judge whether there is stored data in this subscript if (bunck === undefined) { return false; } // Traverse the array of corresponding Subscripts for (let i: number = 0; i < bunck.length; i++) { if (bunck[i][0] === key) { // If yes, the corresponding value is returned return bunck[i][1]; } } return false; } // Delete method remove(key: unknown): boolean { // To get the index, you need to use the hash function let index: number; index = this.runHashFunc(key, this.limit); // Find the array corresponding to the subscript let bunck: unknown[] = this.message[index]; // Judge whether there is stored data in this subscript if (bunck === undefined) { return false; } // Traverse the array of corresponding Subscripts for (let i: number = 0; i < bunck.length; i++) { if (bunck[i][0] === key) { // If found, the element (array) corresponding to the subscript array is returned bunck.splice(i, 1); // Hash table length containing data  1 this.count = 1; return true; } } return false } //Judge whether the hash table is empty isEmpty():boolean{ return this.count === 0; } //Gets the number of hash table elements size():number{ return this.count; } }
Note that value is the description and data of the corresponding key data
test
let hash = new MyHashTable(); hash.alter('a', 4); hash.alter('b', 33); hash.alter('s', 45); hash.alter('ae', 4); hash.alter('bg', 333); hash.alter('rs', 444); console.log(hash.getNode('s')); //45 console.log(hash.getNode('a')); //4 hash.remove('a'); console.log(hash.getNode('a')); //false
Expansion of hash table

Theoretically, the data stored in the subscript position of the hash table can be extended infinitely, but with the increase of the amount of data, the detection length will become larger and larger, and the detection here mainly uses ordinary traversal, resulting in lower and lower efficiency. We need to expand the capacity at the appropriate position

It is best to expand the hash table. The final capacity is prime, and all data must be reinserted after expansion (because the subscript position obtained after hashing has changed)

The time for capacity expansion is generally when hashcode (fill factor) > 0.75
Implementation of capacity expansion
import {myHash} from "./Implement hash table"; // Implementation of capacity expansion class ResizeHashTable extends myHash { // Hash table insertion and modification methods alter(key: unknown, value: number): boolean { let index: number; // Get the corresponding index (subscript) according to the key (hashed) index = this.runHashFunc(key, this.limit); // When number of data items / hash table length = fill factor > 0.75 if (this.count / this.limit >= 0.75) { console.warn('The hash table data capacity is about to overflow. Please expand it in time hash'); // Automatic capacity expansion twice the current hash length let newSize: number = this.limit * 2, // Gets a prime number of suitable length newPirme: number = this.getPrime(newSize); // Capacity expansion this.resize(newPirme); } // Create an array with a length corresponding to the subscript position let bunck: unknown = this.message[index]; // When there is no array at the corresponding subscript position, create an array and place it at the corresponding subscript position if (bunck === undefined) { bunck = []; this.message[index] = bunck; } // In case of modification for (let i = 0; i < bunck.length; i++) { // Find the key of the qualified tuple corresponding to the subscript and modify the key if (bunck[i][0] === key) { bunck[i][1] = key; return true; } } //Insert operation bunck.push([key, value]); this.count += 1; return true; }  //Override delete method remove(key: unknown): boolean { // To get the index, you need to use the hash function let index: number; index = this.runHashFunc(key, this.limit); // Find the array corresponding to the subscript let bunck: unknown[] = this.message[index]; // Judge whether there is stored data in this subscript if (bunck === undefined) { return false; } // Traverse the array of corresponding Subscripts for (let i: number = 0; i < bunck.length; i++) { if (bunck[i][0] === key) { // If found, the element (array) corresponding to the subscript array is returned bunck.splice(i, 1); // Hash table length containing data  1 this.count = 1; // When the number of data items / hash table length = fill factor < 0.25 and the minimum hash length cannot be less than 10 if (this.count / this.limit < 0.25 && this.limit > 10) { // Automatically reduce the capacity by twice the current hash length let newSize: number = Math.floor(this.limit / 2), // Gets a prime number of suitable length newPirme: number = this.getPrime(newSize); // Reduce capacity this.resize(newPirme); } return true; } } return false }  // Adding a method of expanding hash table // Newlimit  > new hash table length resize(newLimit): boolean { // Create a variable to receive the old hash table let oldHash: unknown[]; oldHash = this.message; // Initializes the current hash table this.message = []; this.count = 0; // Change the current hash table length to the new hash table length this.limit = newLimit; // Traverse the data array corresponding to each subscript for (let i: number = 0; i < oldHash.length; i++) { // Reinsert the new hash table when there is data in the array if (oldHash[i] !== undefined) { for (let j: number = 0; j < oldHash[i].length; j++) { // Add the currently traversed key and value into the new hash table this.alter(oldHash[i][j][0], oldHash[i][j][1]); } } else { // Skip when there is no data in the current array continue; } } return true; }  // Get the overall hash structure get hash(): unknown[] { return this.message; }  // Judge prime number  used to judge whether the hash length of the expansion is a prime number so that the data is evenly distributed private ifnum(num: number): boolean { // Get square root let sqrt: number = Math.floor(Math.sqrt(num)); // When it is half checked, there is no need to continue to traverse the judgment index, just like 3 * 2 = 2 * 2 for (let i: number = 2; i < sqrt; i++) { if (num % i === 0) { return false } } return true; }  // Get prime private getPrime(num: number): number { // Receive new length // If the new length is not a prime number, it will be incremented while (!this.ifnum(num)) { num++; } // If it is a prime number, it returns a prime number return num; } } let hash = new ResizeHashTable(); hash.alter('a', 4); hash.alter('b', 33); hash.alter('s', 45); hash.alter('ea', 4565); hash.alter('ae', 4); hash.alter('bg', 333); hash.alter('rs', 444); // Capacity expansion hash.resize(20); console.log(hash.hash); //[ // <9 empty items>, // [ [ 'bg', 333 ] ], // [ [ 'ae', 4 ] ], // <2 empty items>, // [ [ 'rs', 444 ] ], // [ [ 'ea', 4565 ] ], // [ [ 's', 45 ] ], // <1 empty item>, // [ [ 'a', 4 ] ], // [ [ 'b', 33 ] ] // ]