FEAT: add linear probing notes and demo notebook

Author: MKaczkow

README.md

@@ -23,3 +23,4 @@ Repo for general concepts for working with python (e.g. regex, files operations,
 15. [gRPC](https://github.com/MKaczkow/python_concepts/tree/master/grpc_example)
 16. [PageRank](https://github.com/MKaczkow/python_concepts/tree/master/page_rank)
 17. [Graphs](https://github.com/MKaczkow/python_concepts/tree/master/graphs)
+18. [Linear probing (hash collisions resolution)](./linear_probing)

linear_probing/DEMO.ipynb

@@ -0,0 +1,109 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from hash_table import HashTable"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "ht = HashTable(10)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "print(ht)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "ht.insert(\"apple\", 1)\n",
+    "ht.insert(\"banana\", 2)\n",
+    "ht.insert(\"cherry\", 3)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "print(ht)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "ht.insert(\"kiwi\", 1)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "print(ht)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "print(ht.get(\"apple\"))\n",
+    "print(ht.get(\"banana\"))\n",
+    "print(ht.get(\"cherry\"))\n",
+    "print(ht.get(\"kiwi\"))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "venv",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.0"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

linear_probing/README.md

@@ -0,0 +1,32 @@
+# Linear probing
+*... is a way of resolving hash collisions*
+
+## General
+* there are different strategies for resolving hash collisions, linear probing is one of them
+* still pretty good, despite being created in 1954
+
+### Hashing strategies
+* `closed addressing` -> all elements with hash collisions are stored in some secondary data structure
+```python
+if key in hash_map:
+    hash_map[key].append(value)
+else:
+    hash_map[key] = [value]
+```
+* `perfect hashing` -> no collisions (e.g. `cuckoo hashing`)
+* `open addressing` -> elements may *leak out*
+
+### Linear probing (open addressing)
+* `on insert`
+  * compute h(x)
+  * try to insert x at h(x)
+  * if h(x) is occupied, try h(x+1), h(x+2), ...
+* `on delete`
+  * use `tombstones` to mark cell as *empty, but previously occupied*
+  * on lookup, we don't stop at tombstones 
+
+### Primary clustering
+* main problem, causing linear probing performance to degrade
+
+## References
+* [stanford lecture](https://web.stanford.edu/class/archive/cs/cs166/cs166.1166/lectures/12/Small12.pdf)

linear_probing/__init__.py

@@ -0,0 +1,34 @@
+class HashTable:
+    def __init__(self, size):
+        self.size = size
+        self.table = [None] * size
+
+    def hash_function(self, key):
+        # A vary simple hash function (modulo)
+        return hash(key) % self.size
+
+    def insert(self, key, value):
+        index = self.hash_function(key)
+
+        # Linear probing for collision resolution
+        while self.table[index] is not None:
+            index = (index + 1) % self.size
+
+        self.table[index] = (key, value)
+
+    def get(self, key):
+        index = self.hash_function(key)
+
+        original_index = index  # Keep track of where we started (prevent infinite loop)
+        while self.table[index] is not None:
+            if self.table[index][0] == key:
+                return self.table[index][1]
+            index = (index + 1) % self.size
+
+            if index == original_index:  # Means we've looped through the whole table
+                return None
+
+        return None
+
+    def __str__(self):
+        return str(self.table)