Implement:

HashTableLinearProbing HashTableSeparateChaining

Author: hamednikzad

TODO.md

@@ -2,8 +2,6 @@
 
 Here is Data Structures base on https://en.wikipedia.org/wiki/List_of_data_structures
 
-
-
 ## Data Structures
 
 ### Abstract data types
@@ -18,7 +16,9 @@ Here is Data Structures base on https://en.wikipedia.org/wiki/List_of_data_struc
 - [x] Queue (example Priority queue)
 - [ ] Double-ended queue
 - [ ] Graph (example Tree, Heap)
-- [ ] Hash Table
+- [x] Hash Table
+ - [x] Linear Probing Technique
+ - [x] Separate Chaining Technique
 - [ ] Dictionary
 
 ### Linear 
@@ -74,7 +74,7 @@ Here is Data Structures base on https://en.wikipedia.org/wiki/List_of_data_struc
  -[ ] Dynamic perfect hash table
  -[ ] Hash array mapped trie
  -[ ] Hash list
- -[ ] Hash table
+ -[x] Hash table
  -[ ] Hash tree
  -[ ] Hash trie
  -[ ] Koorde

src/ConsoleApp/Program.cs

@@ -1,4 +1,5 @@
 using DataStructures.AbstractDataTypes.Arrays;
+using DataStructures.AbstractDataTypes.Hashes;
 using DataStructures.AbstractDataTypes.Lists;
 using DataStructures.AbstractDataTypes.Queues;
 using DataStructures.AbstractDataTypes.Stacks;
@@ -12,20 +13,40 @@
 //StackUsage();
 //LinkedListStackUsage();
 //LinedListQueueUsage();
-HashSetUsage();
+//HashSetUsage();
+//HashTableSeparateChainingUsage();
+HashTableLinearProbingUsage();
 
 
+
+void HashTableLinearProbingUsage()
+{
+ var hashTable = new HashTableLinearProbing<int>(2);
+ for (var i = 0; i < 50; i++)
+ {
+ hashTable.Add(i);
+ }
+ Console.WriteLine($"Table Count:{hashTable.Count}");
+ foreach (var item in hashTable)
+ {
+ Console.WriteLine($"Item:{item}");
+ }
+ hashTable.Remove(2);
+ hashTable.Contains(2);
+ Console.WriteLine($"Table New Count:{hashTable.Count}");
+}
+
 void ArrayUsage()
 {
- SimpleArray.Sort(new[] {7, 5, 3, 9}); 
+ SimpleArray.Sort(new[] { 7, 5, 3, 9 });
 }
 
 void ArrayListUsage()
 {
  var arrayList = new ArrayList();
  arrayList.Add("Item 1");
  arrayList.Add(2);
- var exists = arrayList.Contains(2); 
+ var exists = arrayList.Contains(2);
  Console.WriteLine($"Element 2 Exists: {exists}");
 }
 
@@ -38,7 +59,7 @@ void ListUsage()
  3,
  4
  };
- 
+
  foreach (var item in list)
  {
  Console.WriteLine(item);
@@ -114,7 +135,7 @@ void LinedListQueueUsage()
  queue.Enqueue(2);
  queue.Enqueue(3);
  queue.Enqueue(4);
- 
+
  var first = queue.Peek();
  var e1 = queue.Dequeue();
  var e2 = queue.Dequeue();
@@ -134,4 +155,20 @@ void HashSetUsage()
 
  var isExist = set.Contains("Name 2");
  //set.Remove("Name 2");
+}
+
+void HashTableSeparateChainingUsage()
+{
+ var hashTable = new HashTableSeparateChaining<int>(4);
+ for (var i = 0; i < 50; i++)
+ {
+ hashTable.Add(i);
+ }
+ Console.Write($"Table Count:{hashTable.Count}");
+ foreach (var item in hashTable)
+ {
+ Console.WriteLine(item);
+ }
+
+ var exists = hashTable.Contains(4);
 }

src/DataStructures/AbstractDataTypes/Hashes/HashSet.cs

@@ -48,6 +48,7 @@ private void Resize()
  var newSize = _capacity * 2;
  Resize(newSize);
  }
+ 
  private void Resize(int newSize)
  {
  var newEntries = new Entry[newSize];

src/DataStructures/AbstractDataTypes/Hashes/HashTableLinearProbing.cs

@@ -0,0 +1,148 @@
+using System.Collections;
+
+namespace DataStructures.AbstractDataTypes.Hashes;
+
+public class HashTableLinearProbing<T> : IEnumerable<T>
+{
+ private class Item
+ {
+ public readonly T Data;
+
+ public Item(T data)
+ {
+ Data = data;
+ }
+ }
+ 
+ private int _size;
+ private int _free;
+ private Item?[] _entries;
+ public int Count { get; private set; }
+
+ public HashTableLinearProbing()
+ {
+ _size = 20;
+ _free = _size;
+ _entries = new Item[_size];
+ }
+
+ public HashTableLinearProbing(int size)
+ {
+ _size = size;
+ _free = size;
+ _entries = new Item[_size];
+ }
+
+ private static int GetHash(T item)
+ {
+ return item!.GetHashCode();
+ }
+
+ private int GetHashIndex(T item)
+ {
+ return GetHash(item) % _size;
+ }
+
+ public bool Contains(T data)
+ {
+ var index = GetHashIndex(data);
+ var comparer = EqualityComparer<T>.Default;
+
+ for (var i = 0; i < _size; i++)
+ {
+ var index2 = (i + index) % _size;
+ var item = _entries[index2];
+ if (item is not null && comparer.Equals(item.Data, data))
+ return true;
+ }
+
+ return false;
+ }
+
+ public void Remove(T data)
+ {
+ var index = GetHashIndex(data);
+ var comparer = EqualityComparer<T>.Default;
+
+ for (var i = 0; i < _size; i++)
+ {
+ var index2 = (i + index) % _size;
+ var item = _entries[index2];
+ if (item is not null && !comparer.Equals(item.Data, data)) continue;
+ 
+ _entries[index2] = null;
+ Count--;
+ return;
+ }
+ }
+
+ public bool Add(T data)
+ {
+ if (Contains(data))
+ return false;
+
+ if (_free <= 0)
+ Expand();
+
+ var index = GetHashIndex(data);
+ for (var i = 0; i < _size; i++)
+ {
+ var index2 = (i + index) % _size;
+ if (_entries[index2] is not null) continue;
+
+ _entries[index2] = new Item(data);
+ Count++;
+ _free--;
+ return true;
+ }
+
+ return false;
+ }
+
+ private void Expand()
+ {
+ var newSize = _size * 2;
+ var newEntries = new Item?[newSize];
+ var newFree = newSize;
+ var count = 0;
+ for (var i = 0; i < _size; i++)
+ {
+ var item = _entries[i];
+ if(item is null)
+ continue;
+
+ var hash = GetHash(item.Data);
+ var index = hash % newSize;
+ for (var j = 0; j < newSize; j++)
+ {
+ var index2 = (j + index) % newSize;
+ if (newEntries[index2] is not null) continue;
+
+ newEntries[index2] = item;
+ count++;
+ newFree--;
+ break;
+ }
+ }
+ 
+ _size = newSize;
+ _entries = newEntries;
+ _free = newFree;
+ Count = count;
+ }
+
+ public IEnumerator<T> GetEnumerator()
+ {
+ for (var i = 0; i < _size; i++)
+ {
+ var item = _entries[i];
+ if (item is not null)
+ yield return item.Data;
+ }
+ }
+
+ IEnumerator IEnumerable.GetEnumerator()
+ {
+ return GetEnumerator();
+ }
+}