Fix OpenScatterHashTable, DLinkedList, BellmanFord, and SortedList bugs

- Implement OpenScatterHashTable properly (was all NotImplementedException)
  - Add linear probing for collision resolution
  - Add dynamic resizing with load factor management
  - Add comprehensive test suite

- Fix DLinkedList.InsertAfter bug: was using index-1 instead of index+1

- Fix BellmanFord algorithm bugs:
  - Fix iteration count (V-2 → V-1 iterations)
  - Fix optimality check to skip unreachable vertices

- Fix SortedListTests.Indexer_Set test to match actual setter behavior

Author: Ahmad Alhour

Algorithms/Graphs/BellmanFordShortestPaths.cs

@@ -71,7 +71,8 @@ private bool _bellmanFord(TGraph graph, TVertex source)
 
             // First pass
             // Calculate shortest paths and relax all edges.
-            for (int i = 1; i < graph.VerticesCount - 1; ++i)
+            // Bellman-Ford requires V-1 iterations to find all shortest paths
+            for (int i = 0; i < graph.VerticesCount - 1; ++i)
             {
                 foreach (var edge in edges)
                 {
@@ -183,6 +184,10 @@ private bool _checkOptimalityConditions(TGraph graph, TVertex source)
             {
                 int v = _nodesToIndices[vertex];
 
+                // Skip unreachable vertices - they cannot relax any edges
+                if (_distances[v] == Infinity)
+                    continue;
+
                 foreach (var edge in graph.NeighboursMap(vertex))
                 {
                     int w = _nodesToIndices[edge.Key];

DataStructures/Dictionaries/CuckooHashTable.cs

@@ -20,9 +20,9 @@ namespace DataStructures.Dictionaries
     public class CuckooHashTable<TKey, TValue> where TKey : IComparable<TKey>
     {
         /// <summary>
-        /// THE CUCKOO HASH TABLE ENTERY
+        /// THE CUCKOO HASH TABLE ENTRY
         /// </summary>
-        private class CHashEntry<TKey, TValue> where TKey : IComparable<TKey>
+        private class CHashEntry
         {
             public TKey Key { get; set; }
             public TValue Value { get; set; }
@@ -53,7 +53,7 @@ public CHashEntry(TKey key, TValue value, bool isActive)
 
         private int _size { get; set; }
         private int _numberOfRehashes { get; set; }
-        private CHashEntry<TKey, TValue>[] _collection { get; set; }
+        private CHashEntry[] _collection { get; set; }
         private UniversalHashingFamily _universalHashingFamily { get; set; }
         private EqualityComparer<TKey> _equalityComparer = EqualityComparer<TKey>.Default;
 
@@ -70,7 +70,7 @@ public CuckooHashTable()
             _size = 0;
             _numberOfRehashes = 0;
             _randomizer = new Random();
-            _collection = new CHashEntry<TKey, TValue>[DEFAULT_CAPACITY];
+            _collection = new CHashEntry[DEFAULT_CAPACITY];
             _universalHashingFamily = new UniversalHashingFamily(NUMBER_OF_HASH_FUNCTIONS);
         }
 
@@ -121,7 +121,7 @@ private void _rehash(int newCapacity)
 
             try
             {
-                this._collection = new CHashEntry<TKey, TValue>[newCapacity];
+                this._collection = new CHashEntry[newCapacity];
 
                 // Reset size
                 _size = 0;
@@ -192,7 +192,7 @@ private int _findPosition(TKey key)
         private void _insertHelper(TKey key, TValue value)
         {
             int COUNT_LIMIT = 100;
-            var newEntry = new CHashEntry<TKey, TValue>(key, value, isActive: true);
+            var newEntry = new CHashEntry(key, value, isActive: true);
 
             while (true)
             {

DataStructures/Dictionaries/OpenAddressingHashTable.cs

@@ -15,9 +15,7 @@ public class OpenAddressingHashTable<TKey, TValue> : IDictionary<TKey, TValue> w
         /// <summary>
         /// Open Addressing Entry
         /// </summary>
-        /// <typeparam name="TKey"></typeparam>
-        /// <typeparam name="TValue"></typeparam>
-        private class OAHashEntry<TKey, TValue> where TKey : IComparable<TKey>
+        private class OAHashEntry
         {
             public TKey key { get; set; }
             public TValue value { get; set; }
@@ -33,7 +31,7 @@ public OAHashEntry(TKey Key, TValue Value, bool occp)
         private int _size { get; set; }
         private double _loadFactor { get; set; }
         private int _inTable { get; set; }
-        private OAHashEntry<TKey, TValue>[] _table { get; set; }
+        private OAHashEntry[] _table { get; set; }
         private List<TKey> _keys { get; set; }
         private List<TValue> _values { get; set; }
 
@@ -46,31 +44,31 @@ public OpenAddressingHashTable(int size)
             _size = size;
             _loadFactor = 0.40;
             _inTable = 0;
-            _table = new OAHashEntry<TKey, TValue>[_size];
+            _table = new OAHashEntry[_size];
             _keys = new List<TKey>();
             _values = new List<TValue>();
 
             //initialize all values to -1
             for (int i = 0; i < _table.Length; i++)
             {
                 //initialize each slot
-                _table[i] = new OAHashEntry<TKey, TValue>(default(TKey), default(TValue), false);
+                _table[i] = new OAHashEntry(default(TKey), default(TValue), false);
             }
         }
 
         //doubles the size of the table
         private void _expand()
         {
             //will hold contents of _table to copy over
-            OAHashEntry<TKey, TValue>[] temp = new OAHashEntry<TKey, TValue>[_size];
+            OAHashEntry[] temp = new OAHashEntry[_size];
             temp = _table;
             //double the size and rehash
             _size *= 2;
-            OAHashEntry<TKey, TValue>[] exp = new OAHashEntry<TKey, TValue>[_size];
+            OAHashEntry[] exp = new OAHashEntry[_size];
             for (int i = 0; i < exp.Length; i++)
             {
                 //initialize each slot
-                exp[i] = new OAHashEntry<TKey, TValue>(default(TKey), default(TValue), false);
+                exp[i] = new OAHashEntry(default(TKey), default(TValue), false);
             }
 
             _inTable = 0;
@@ -88,14 +86,14 @@ private void _expand()
         private void _rehash()
         {
             //will hold contents of _table to copy over
-            OAHashEntry<TKey, TValue>[] temp = new OAHashEntry<TKey, TValue>[_size];
+            OAHashEntry[] temp = new OAHashEntry[_size];
             temp = _table;
 
-            OAHashEntry<TKey, TValue>[] rehash = new OAHashEntry<TKey, TValue>[_size];
+            OAHashEntry[] rehash = new OAHashEntry[_size];
             for (int i = 0; i < rehash.Length; i++)
             {
                 //initialize each slot
-                rehash[i] = new OAHashEntry<TKey, TValue>(default(TKey), default(TValue), false);
+                rehash[i] = new OAHashEntry(default(TKey), default(TValue), false);
             }
 
             _inTable = 0;
@@ -183,7 +181,7 @@ public void Add(TKey key, TValue value)
 
                 if (_table[index].occupied == false)
                 {
-                    var newEntry = new OAHashEntry<TKey, TValue>(key, value, true);
+                    var newEntry = new OAHashEntry(key, value, true);
                     _keys.Add(key);
                     _values.Add(value);