1. Hash table
Why is there a hash table?
For example, chestnuts:
There are thousands of employees in a company. How do I find an employee's information
Through the array, each employee corresponds to a job number. I can directly find the job number to obtain the corresponding information
But I don't want to get it through the job number. I want to get it through the employee's name. At this time, I will think of the linked list, but the problem comes. The linked list is an information linked to one information, and the efficiency is very slow
At this time, the hash table can be used. The name of each employee can be converted into a corresponding number, and the number corresponds to the name. In this way, I can obtain the employee information directly through the number
1.1 hashing
The process of converting large numbers into subscripts within the array range (the range here is defined by itself). For example, 0100 takes the remainder 10 to get the subscript value of 09 (there are many ways, such as bit operation in java). This process is called hashing
If there are 5000 words, an array with a length of 5000 may be defined, but in practice, we can't guarantee that the large numbers corresponding to these words are completely different, so we need to double the size of 10000. Although the length of the array is enough, the index after hashing may still be repeated, At this time, it is necessary to resolve conflicts (conflicts here refer to the hash of large numbers, not large numbers)
1.2 hash function
Usually, we will convert words into large numbers (power multiplication). The code of large numbers after hashing will be processed by a function to get the desired data. This function is the hash function
Why convert words into large numbers: because we need to convert the corresponding words into a very large number in an appropriate way, so that they will not be repeated with other words, ensuring that each word has a corresponding number (but if the data is too large, it needs to be hashed)
1.3 hash table
Finally, the data is inserted into an array, which is called a hash table
1.4 conflict resolution

What is conflict? Conflict means that there will be the same subscript value after hashing. There are two ways to solve conflict: chain address method and development address method

Chain address method

The solution to the conflict of chain address method is that the data stored in each array is no longer a single data, but a linked list or array

When querying, first find the corresponding position according to the hashed subscript, and then perform linear search in the corresponding position

The problem is whether to select a linked list or an array. In fact, they are almost the same, because there are few conflicts (but we need to solve them), which means that the length of the linked list or array behind it will not be very long. They are all linear checks, and the efficiency is not much worse

The choice of linked list or array depends on the demand. Both linked list and array have their own advantages and disadvantages. Array is suitable for inspection and modification, and linked list is suitable for insertion and deletion

Open address method

Developing the address method is to find a blank location to store conflicting data, because after processing, the length of the storage array is enough to store these data (if the length is not enough, it will expand), but there will be conflicts after hashing. The efficiency of developing the address method is higher than that of the chain address method. There are three ways to develop the address method, linear detection Secondary detection, re Hashimoto

Linear detection
Insert: suppose that there is a data of 22 in the subscript 2, and then I want to insert the data of 32. At this time, linear detection is required. Linear detection is to check the blank unit linearly. If there is no content in the subscript 3, you can use line detection to make index + + (currently refers to 2). When it is added to 3, 32 is inserted, Linear detection will only start from the corresponding subscript, not from scratch
Query: the idea of query is the same as that of insertion. If there are values 62, 72, etc., there is also the idea of querying the value of index=2. For example, I want to check whether there is 102. Linear search stops when an empty position has not been found, because all empty positions will be excluded when inserting. All empty positions have been found and have not been found, It can already indicate that there is no such value
Delete: the same idea applies to deletion and query insertion. However, it should be noted that after deletion, the content of this subscript cannot be set to null, because if it is set to null, an empty item will be found during query insertion and deletion, so it will not be detected backward. Then, it will not be found when I save 62 and 72, Therefore, after deletion, special processing needs to be done (for example, set to  1), indicating that it is deleted, and there may be the same type behind it (here, the type refers to 2 at the end, which can be distinguished after hashing), and then it can be placed at this  1 position when inserting again
Linear detection: a serious problem with linear detection is aggregation. For example, when we do not have any data, we insert some data 222324252627, which means that there are elements at the position of 234567. This series of data is called aggregation. Aggregation will affect the performance of hash table, whether it is insertion, deletion or query, For example, if we insert a 32, we will find that there is data from 27, but it will still detect bit by bit, which is particularly performance consuming. At this time, we need secondary detection. Secondary detection can solve some of this problem

Secondary detection
Secondary detection is actually an improved version of linear detection: linear detection is x+1, x+2 and x+3 step by step, while secondary detection is x+1 (square), x+2 (square) and x+3 (square). Other operations are the same as linear detection, that is, the step size is different
The problem of secondary detection: if we insert the data of 3211242922, this situation will also cause a focus with different steps. At this time, we need Hashi method to fundamentally solve the problem

double hashing
Re hashing method: linear detection and secondary detection will have corresponding focusing problems. In order to solve these problems, it is necessary to use hashing method. Re hashing method detects according to keywords. Even if different keywords are mapped to the same array subscript (conflict), different detection sequences (steps) can be used, and different steps can be used for different keywords, Unlike the first hash function, the second hash function cannot output 0, because the output of 0 means that there is no step size, and the algorithm enters an endless loop
New hash function: stepsize = constant  (key% constant), where key is the length of the data, constant is a prime number, and is less than the capacity of the array. For example, stepsize = 5  (key% 5), the result can not be 0 in any case
1.5 efficiency of hashing
 If there is no conflict, the efficiency will be very high
 In case of conflict, the access time depends on the subsequent detection length. The average detection length and average access time depend on the loading factor. As the loading factor becomes larger, the detection length becomes longer and longer
 Loading factor = total data item / hash table length
 The loading factor of open address method can only be 1 at most, because it must find a blank cell to put elements into
 The loading factor of chain address method can be greater than 1, because the zipper of chain address method can extend indefinitely (the efficiency is getting lower and lower at the back)
1.6 excellent hash function

Fast calculation

Using multiplication in a computer is very performance consuming

To convert the corresponding data to a large number, we use the power multiplication. Here, we will use a lot of multiplication, such as
cats = 3 * 27^3 + 1*27^2 + 20 * 27^1 + 17 * 27^0 = 60337
Note: 27 is the base of the power selected by yourself, ^ represents the power, and 3, 1, 20 and 17 represent the code of the corresponding word
Each word is converted in this way, which can be represented by N. after a series of simplification operations, the multiplication times become n(n+1)/2 times, and the addition times are n times

Horner's rule: in order to solve this kind of evaluation problem, Horner's rule is also called Qin Jiushao algorithm in China
After the change of Horner's law, the number of multiplication is n times and the number of addition is n times
If large o is used to represent time complexity, it is directly reduced from O(N^2) to O(N)


Uniform distribution

In hash table, whether chain address method or open address method, when multiple elements are mapped to the same location, it will affect the efficiency

Therefore, an excellent hash function should map elements to different locations as much as possible when elements are evenly distributed in the hash table

For uniform distribution, try to use prime numbers when using constants
The length of the hash table and the base of the power all use prime numbers. In order to make the hash table more evenly distributed, hashing method is also easier to find
For example, chestnuts:
If the container length is 15 (subscript value 0 ~ 14), calculate the step to be found through the function of rehash method: 5  (15% 5) = 5 (step)
Detection sequence: 0  5  10  0  5  10... If there is data in 0, 5 and 10, the program will become an endless loop
If the container length is 13 (subscript value 0 ~ 12), the search step is 5  (13% 5) = 2 (step)
Detection sequence: 0  2  4  6  8  10  12  1  3  5  7  9  11. Every position will be detected
When trying one, the container length is 7 (subscript value 0 ~ 6), and the search step is 5  (7% 5) = 3 (step)
Detection sequence: 0  3  6  2  5  1  4. Each position will also be detected
In this way, not only will there be no loop, but also the data can be more evenly distributed in the hash table (mathematical knowledge is designed in this)

1.7 hash table expansion
 In the chain address method, the loading factor can be greater than 1
 However, as the amount of data increases, the bucket corresponding to each index will become longer and longer, which will reduce the efficiency
 Therefore, it is necessary to expand the capacity of the array at this time
 It is common to expand the capacity when the loading factor is > 0.75, and the expansion efficiency is the highest at this time
 After capacity expansion, empty the data in the previous array and add it to the new array again
 With capacity expansion, of course, there will be corresponding capacity reduction. The implementation principle of capacity reduction is actually the same as that of capacity expansion
 Shrink the volume when the filling factor is < 0.25
 Because if there is no capacity reduction and only capacity expansion, I always add data, and then the array will continue to expand, and then I always delete data. At this time, there will be many empty positions in the array, wasting a lot of unnecessary space, so I also need to use capacity reduction
1.8 hash table encapsulation (chain address method)

hash function
// Encapsulate hash function // str: data to be converted to a large number // size: the length of the array function hashFn(str, size) { // Store large numbers let hashCode = 0 // Horner's Law: efficient computing // ((...(((anx + an  1)x + an  2)x + an  3)...)x + a1)x + a0 for (let i = 0; i < str.length; i++) { // Charcodeat  > to Unicode encoding // 37 the prime number you choose is more than 37 hashCode = hashCode * 37 + str.charCodeAt(i) } // The length of the array is modular (hashed), which is convenient for storing different corresponding positions let index = hashCode % size return index }

Efficient judgment of prime numbers
function isPrime(num) { // Sqrt (n)  > refers to the square root of n // If a number n can be factorized, the two numbers obtained by factorization // There must be one less than or equal to sqrt(n) and one greater than or equal to sqrt(n) let temp = parseInt(Math.sqrt(num)) for (let i = 2; i <= temp; i++) { if (num % i == 0) { return false } } return true }

Hashtable
// The addition, deletion, modification and query of hash table are the same // 1. Take out the corresponding subscript through hash function conversion, that is, the bucket of data to be stored // 2. Check whether the bucket is empty // (1) In the addition operation, if the bucket is empty, create a bucket (array is used here, and the efficiency of array and linked list is similar) // (2) In the hash table, adding and modifying are the same method, because the key is used to add or modify data, // Adding without a key is equivalent to adding, and modifying value with a key is equivalent to modifying // (3) In query and deletion, if there is no bucket, the operation corresponding to the operation failure is returned // 3. Traverse the bucket and add, delete, modify and query. The second point refers to the bucket, and the third point refers to the data in the bucket. The ideas are the same // 4. Add and delete operations that only exist // (1) Add, add 1 to the content length, and then check whether it needs to be expanded // (2) Delete, the content length is reduced by 1, and delete to see whether it needs to shrink // (3) After capacity expansion or reduction, the data must also be prime // Hash table class class HashTable { constructor() { // Outermost large array (hash table) this.storage = [] // Data volume (total length of data content) this.count = 0 // Hash table length this.limit = 7 } // Encapsulate hash function // str: data to be converted to a large number // size: the length of the array hashFn(str, size) { // Store large numbers let hashCode = 0 // Horner's Law: efficient computing // ((...(((anx + an  1)x + an  2)x + an  3)...)x + a1)x + a0 for (let i = 0; i < str.length; i++) { // Charcodeat  > to Unicode encoding // 37 the prime number you choose is more than 37 hashCode = hashCode * 37 + str.charCodeAt(i) } // The length of the array is modular (hashed), which is convenient for storing different corresponding positions let index = hashCode % size return index } // 1.put(key, value): insert and modify data put(key, value) { // Take out the corresponding subscript to be put in let index = this.hashFn(key, this.limit) // Bucket: because of the selected chain address method, each corresponding subscript must store an array (bucket) let bucket = this.storage[index] // If the bucket does not exist, it indicates the first insertion value. You need to create the bucket and place it at the corresponding subscript position if (bucket == null) { bucket = [] this.storage[index] = bucket } // If the data is added for the first time, the loop will not come in (bucket.length == 0) for (let i = 0; i < bucket.length; i++) { // Each item of data is also stored in an array, [key, value] let data = bucket[i] // If the same key is found, modify it if (data[0] == key) { data[1] = value return } } // Add without bucket.push([key, value]) // Add data content plus one this.count++ // When the loading factor is > 0.75, expand the capacity of the array hash table if (this.count > this.limit * 0.75) { // Check whether this number is a prime number. If yes, it will return and if not, it will become a prime number let prime = this.setPrime(this.limit * 2) this.resize(prime) } } // 2.get(key): get data get(key) { // Take out the corresponding subscript to find let index = this.hashFn(key, this.limit) // Remove the current bucket let bucket = this.storage[index] // If the bucket is empty, return directly if (bucket == null) { console.log("The bucket is empty"); return } for (let i = 0; i < bucket.length; i++) { let data = bucket[i] // Find the key equal and return value if (data[0] == key) { return data[1] } } return "There is no such data" } // 3.remove(key): delete data and return it remove(key) { let index = this.hashFn(key, this.limit) let bucket = this.storage[index] if (bucket == null) { console.log("The bucket is empty"); return } for (let i = 0; i < bucket.length; i++) { let data = bucket[i] if (data[0] == key) { // Delete the current item when it matches bucket.splice(i, 1) this.count // The minimum hash table length is 7 (because it is too small and unnecessary) // When the filling factor is < 0.25, the volume is reduced if (this.limit > 7 && this.count < this.limit * 0.25) { let prime = this.setPrime(Math.floor(this.limit / 2)) this.resize(prime) } return data[1] } } return "There is no such data" } // 4.isEmpty(): check whether the hash table is empty, return true if it is empty, and return false if it is not empty isEmpty() { return this.count == 0 } // 5.size(): get the number of elements in the hash table size() { return this.count } // resize(newLimit): hash table capacity expansion / reduction resize(newLimit) { // Save the original data first let oldStorage = this.storage // Initialize and then change the hash table length this.storage = [] this.count = 0 this.limit = newLimit // for (let i = 0; i < oldStorage.length; i++) { let bucket = oldStorage[i] // Skip if empty if (bucket == null) { continue } // If there are any values, they are all added to the new hash table length for (let i = 0; i < bucket.length; i++) { let data = bucket[i] this.put(data[0], data[1]) } } } // isPrime(num): determines whether a number is a prime number. It is true, not false isPrime(num) { // Sqrt (n)  > refers to the square root of n // If a number n can be factorized, the two numbers obtained by factorization // There must be one less than or equal to sqrt(n) and one greater than or equal to sqrt(n) let temp = parseInt(Math.sqrt(num)) for (let i = 2; i <= temp; i++) { if (num % i == 0) { return false } } return true } // setPrime(num): change a number to a prime number setPrime(num) { while (!this.isPrime(num)) { num++ } return num } } // test let hashTable = new HashTable() hashTable.put("Xiao Hong", "1") hashTable.put("Xiaobai", "12") hashTable.put("Blue ", "123") hashTable.put("Little green", "1234") hashTable.put("Xiao Hei", "12345") hashTable.put("Xiaotian", "123456") hashTable.put("Xiao Huang", "1234567") // console.log(hashTable.get("big dog"); // hashTable.get("little black") console.log(hashTable.remove("Xiao Hong")); console.log(hashTable.remove("Xiaobai")); console.log(hashTable.remove("Little green")); console.log(hashTable.remove("Xiao Hei")); // console.log(hashTable.isEmpty()); // console.log(hashTable.size()); console.log(hashTable);