Hash Tables
1059 | Objects and Maps in JavaScript, Dictionaries in Python, Maps in Dart are all Hash Table implementation.
1060 | Working
1061 | Suppose we want to store a key value pair. Arrays are already key value pair implementation where keys are the indices. But suppose we want the key to be strings, in such case we need to use a hash table.
1062 | Consider the following object: {"pink" : "#ff6932", "cyan" : "#00fff"}.
1063 | To store this data we need to use a hash function and an array. Suppose hash("pink") is 25. Thus we will store "#ff6932" at the 25 index of our array. Thus next time whenever we want to access the value of key "pink", we simply have to pass the key thru the hash function and the output index will be used to access the value from array.
1064 | Hash Function
1065 | Hash function is a function that takes any data and converts it into a number.
1066 | Properties of a good hash function:
1067 | 1. Fast (Constant Time)
1068 | 2. Distributes numbers uniformly
1069 | 3. Returns the same index for the same value everytime
1070 | Here’s a hash function
1071 |
// size is the size of array to be used
1072 | function hash(string, size) {
1073 | let total = 0;
1074 | for (char of string) {
1075 | total += char.charCodeAt(0)
1076 | }
1077 | return total % size;
1078 | }
1079 | // removing O(n)
1082 | function hash(string, size) {
1083 | let total = 0;
1084 | for (let i = 0; i < Math.min(string.length, 100); i++) {
1085 | total += string[i].charCodeAt(0)
1086 | }
1087 | return total % size;
1088 | }
1089 | // Increasing randomness
1092 | function hash(string, size) {
1093 | let total = 0;
1094 | const PRIME = 1327;
1095 | for (let i = 0; i < Math.min(string.length, 100); i++) {
1096 | total = (total * PRIME + string[i].charCodeAt(0)) % size;
1097 | }
1098 | return total;
1099 | }
1100 |
1103 | Pro Tip: Use Prime Number length for storing hash tables. https://qr.ae/TWtE8y
1104 |
1105 | Handling Collisions
1106 | What if two strings lead to a same hash?, We solve it by the following methods.
1107 |
1108 | - Separate Chaining:
1109 | Suppose
hash("pink") and hash("orange") gives us a hash of 4. This method stores the key and hash in an array which are stored in an array at the specific index.
1110 |
1111 | For Example: at index 4, we will have the following array after the above hashing: [["pink", "#ff6932"], ["orange", "#aa6666"]]. Thus we will need to search the above array to get our value.
1112 |
1113 | - Linear Probing:
1114 | In this method, if an index is occupied, we look at the next unoccupied index and store our data there. So for the above example, if at index 4 we have
[["pink", "#ff6932"], we will go to index 5 and if it is empty, we will store ["orange", "#aa6666"]. This method exhausts the hash array quickly.
1115 |
1116 | Implementation
1117 | ```javascript
--------------------------------------------------------------------------------
/14-hash-tables/1-hash-tables.md:
--------------------------------------------------------------------------------
1 | # Hash Tables
2 | Objects and Maps in JavaScript, Dictionaries in Python, Maps in Dart are all Hash Table implementation.
3 |
4 | ## Working
5 | Suppose we want to store a key value pair. Arrays are already key value pair implementation where keys are the indices. But suppose we want the key to be strings, in such case we need to use a hash table.
6 | Consider the following object: ```{"pink" : "#ff6932", "cyan" : "#00fff"}```.
7 | To store this data we need to use a hash function and an array. Suppose ```hash("pink")``` is 25. Thus we will store ```"#ff6932"``` at the 25 index of our array. Thus next time whenever we want to access the value of key ```"pink"```, we simply have to pass the key thru the hash function and the output index will be used to access the value from array.
8 |
9 | ## Hash Function
10 | Hash function is a function that takes any data and converts it into a number.
11 |
12 | **Properties of a good hash function:**
13 | 1. Fast (Constant Time)
14 | 2. Distributes numbers uniformly
15 | 3. Returns the same index for the same value everytime
16 |
17 | Here's a hash function
18 | ```javascript
19 | // size is the size of array to be used
20 | function hash(string, size) {
21 | let total = 0;
22 | for (char of string) {
23 | total += char.charCodeAt(0)
24 | }
25 | return total % size;
26 | }
27 | ```
28 | The problem with above function is a bad hash function as its O(n) and not that random.
29 |
30 | ```javascript
31 | // removing O(n)
32 | function hash(string, size) {
33 | let total = 0;
34 | for (let i = 0; i < Math.min(string.length, 100); i++) {
35 | total += string[i].charCodeAt(0)
36 | }
37 | return total % size;
38 | }
39 | ```
40 |
41 | ```javascript
42 | // Increasing randomness
43 | function hash(string, size) {
44 | let total = 0;
45 | const PRIME = 1327;
46 | for (let i = 0; i < Math.min(string.length, 100); i++) {
47 | total = (total * PRIME + string[i].charCodeAt(0)) % size;
48 | }
49 | return total;
50 | }
51 | ```
52 |
53 | > Pro Tip: Use Prime Number length for storing hash tables. https://qr.ae/TWtE8y
54 |
55 | ## Handling Collisions
56 | What if two strings lead to a same hash?, We solve it by the following methods.
57 |
58 | 1. Separate Chaining:
59 | Suppose ```hash("pink")``` and ```hash("orange")``` gives us a hash of 4. This method stores the key and hash in an array which are stored in an array at the specific index.
60 |
61 | For Example: at index 4, we will have the following array after the above hashing: ```[["pink", "#ff6932"], ["orange", "#aa6666"]]```. Thus we will need to search the above array to get our value.
62 |
63 | 2. Linear Probing:
64 | In this method, if an index is occupied, we look at the next unoccupied index and store our data there. So for the above example, if at index 4 we have ```[["pink", "#ff6932"]```, we will go to index 5 and if it is empty, we will store ```["orange", "#aa6666"]```. This method exhausts the hash array quickly.
65 |
66 | ## Implementation
67 | ```javascript
68 | class HashTable {
69 | constructor() {
70 | this.keyMap = new Array(79);
71 | }
72 | _hash(string) {
73 | let total = 0;
74 | const PRIME = 1327;
75 | for (let i = 0; i < Math.min(string.length, 100); i++) {
76 | total = (total * PRIME + string[i].charCodeAt(0)) % 79;
77 | }
78 | return total;
79 | }
80 |
81 | set(key, value) {
82 | let hash = this._hash(key);
83 | if (this.keyMap[hash] == undefined)
84 | this.keyMap[hash] = [
85 | [key, value]
86 | ];
87 | else this.keyMap.push([key, value]);
88 | }
89 |
90 | get(key) {
91 | let hash = this._hash(key);
92 | let chain = this.keyMap[hash];
93 | for (pair of chain)
94 | if (pair[0] === key) return pair[1];
95 | return undefined;
96 | }
97 | pairs() {
98 | let pairs = [];
99 | for (let i = 0; i < 79; i++)
100 | if (banana.keyMap[i] != undefined)
101 | for (let pair of banana.keyMap[i]) pairs.push(pair)
102 | return pairs;
103 | }
104 | }
105 | ```
106 |
107 | ## Complexity
108 | * Insertion: O(1)
109 | * Deletion: O(1)
110 | * Access: O(1)
--------------------------------------------------------------------------------
/15-graphs/1-graphs.md:
--------------------------------------------------------------------------------
1 | # Graphs
2 | Interconnected Nodes. Superset of trees.
3 |
4 | 
5 |
6 | ## Use
7 | 1. Social Network
8 | 2. Networks
9 | 3. Google Maps
10 | 4. Recommendation Engines
11 |
12 | ## Graphs vs Trees:
13 | In trees, for going from one node to another, there is only one path whereas for graphs, there may be multiple paths.
14 |
15 | ## Terminology
16 | 1. **Vertice**: Nodes of the graph
17 | 2. **Edge**: Connections between nodes
18 | 3. **Directed Graph**: Graph in which we can traverse an edge in only one way. Eg: Instagram Followers Graph
19 | 4. **Undirected Graph**: Graph in which nodes can be traversed in both directions. Eg: Facebook Friends Graph
20 | 5. **Unweighted Graph**: Edges have no value associated with them.
21 | 6. **Weighted Graph**: Edges have some value associated with them.
22 |
23 | ## Representing Graphs
24 | There are two ways of representing graphs:
25 |
26 | 1. Adjacency Matrix:
27 |
28 | Is a matrix of size VxV where V is the number of Vertices.
29 | The matrix for the above graph would be:
30 | ```
31 | 0 1 2 3 4
32 | =======================
33 | 0 0 1 0 0 1
34 |
35 | 1 1 0 1 1 1
36 |
37 | 2 0 1 0 1 0
38 |
39 | 3 0 1 1 0 1
40 |
41 | 4 1 1 0 1 0
42 |
43 | ```
44 |
45 | 2. Adjacency List:
46 |
47 | Graph is stored in a list or hashmap:
48 | ```javascript
49 | [
50 | [1, 4],//0
51 | [4, 3, 2],//1
52 | [1, 3],//2
53 | [1, 4, 2],//3
54 | [0, 1, 3],//f
55 | ]
56 |
57 | {
58 | 0 : [1, 4],
59 | 1 : [4, 3, 2],
60 | 2 : [1, 3],
61 | 3 : [1, 4, 1],
62 | 4 : [0, 1, 3],
63 | }
64 | ```
65 |
66 | ## Complexity Comparision
67 | 1. Add Vertex:
68 |
69 | Matrix: O(v