Refactor heuristic node comparing

Author: mitchellri

src/Dijkstra.NET/ShortestPath/AStar.cs

@@ -11,7 +11,7 @@ public static ShortestPathResult GetShortestPath(IDijkstraGraph graph, uint from
             var path = new Dictionary<uint, uint>();
             var distance = new Dictionary<uint, int> {[from] = 0};
             var d = new Dictionary<uint, int> {[from] = 0};
-            var q = new SortedSet<uint>(new[] {from}, new NodeComparer(distance, heuristic));
+            var q = new SortedSet<uint>(new[] {from}, new HeuristicNodeComparer(distance, heuristic));
             var current = new HashSet<uint>();
 
             int Distance(uint key)

src/Dijkstra.NET/ShortestPath/HeuristicNodeComparer.cs

@@ -0,0 +1,30 @@
+using System;
+using System.Collections.Generic;
+
+namespace Dijkstra.NET.ShortestPath
+{
+    internal class HeuristicNodeComparer : NodeComparer
+    {
+        private readonly Func<uint, uint, int> _heuristic;
+
+        public HeuristicNodeComparer(IDictionary<uint, int> distance, Func<uint, uint, int> heuristic) : base(distance)
+        {
+            _heuristic = heuristic;
+        }
+
+        public override int Compare(uint x, uint y)
+        {
+            int xDistance = _distance.ContainsKey(x) ? _distance[x] + _heuristic(x, y) : Int32.MaxValue;
+            int yDistance = _distance.ContainsKey(y) ? _distance[y] + _heuristic(y, x) : Int32.MaxValue;
+
+            int comparer = xDistance.CompareTo(yDistance);
+
+            if (comparer == 0)
+            {
+                return x.CompareTo(y);
+            }
+
+            return comparer;
+        }
+    }
+}

src/Dijkstra.NET/ShortestPath/NodeComparer.cs

@@ -5,28 +5,17 @@ namespace Dijkstra.NET.ShortestPath
 {
     internal class NodeComparer : IComparer<uint>
     {
-        private readonly IDictionary<uint, int> _distance;
-        private readonly Func<uint, uint, int> _heuristic;
+        protected readonly IDictionary<uint, int> _distance;
 
         public NodeComparer(IDictionary<uint, int> distance)
         {
             _distance = distance;
-            _heuristic = null;
-        }
-        public NodeComparer(IDictionary<uint, int> distance, Func<uint, uint, int> heuristic)
-        {
-            _distance = distance;
-            _heuristic = heuristic;
         }
 
-        public int Compare(uint x, uint y)
+        public virtual int Compare(uint x, uint y)
         {
-            int xDistance = _distance.ContainsKey(x) ?
-                _heuristic is null ? _distance[x] : _distance[x] + _heuristic(x, y)
-                : Int32.MaxValue;
-            int yDistance = _distance.ContainsKey(y) ?
-                _heuristic is null ? _distance[y] : _distance[y] + _heuristic(y, x)
-                : Int32.MaxValue;
+            int xDistance = _distance.ContainsKey(x) ? _distance[x] : Int32.MaxValue;
+            int yDistance = _distance.ContainsKey(y) ? _distance[y] : Int32.MaxValue;
 
             int comparer = xDistance.CompareTo(yDistance);
 
@@ -38,4 +27,4 @@ public int Compare(uint x, uint y)
             return comparer;
         }
     }
-}
+}