Extract galloping methods into static GallopingStrategy class

Kalkwst · Kalkwst · commit a66d564c5581 · 2024-09-22T13:33:59.000+03:00
- Moved galloping logic (GallopLeft, GallopRight, LeftRun, RightRun, FinalOffset) from TimSorter to a new GallopingStrategy static class.
- Simplified the code by removing the interface and making all methods static since there's no need for instance-specific behavior.
- The refactored GallopingStrategy class now encapsulates galloping functionality, improving modularity and testability.
- Updated TimSorter to use GallopingStrategy for gallop operations, enhancing code clarity and separation of concerns.
diff --git a/Algorithms.Tests/Sorters/Utils/GallopingStrategyTests.cs b/Algorithms.Tests/Sorters/Utils/GallopingStrategyTests.cs
@@ -0,0 +1,92 @@
+using Algorithms.Sorters.Utils;
+using NUnit.Framework;
+using System.Collections.Generic;
+
+namespace Algorithms.Tests.Sorters.Utils
+{
+    [TestFixture]
+    public class GallopingStrategyTests
+    {
+        private IComparer<int> comparer = Comparer<int>.Default;
+
+[Test]
+        public void GallopLeft_KeyPresent_ReturnsCorrectIndex()
+        {
+            var array = new[] { 1, 2, 3, 4, 5 };
+            var index = GallopingStrategy<int>.GallopLeft(array, 3, 0, array.Length, comparer);
+            Assert.That(index, Is.EqualTo(2));
+        }
+
+        [Test]
+        public void GallopLeft_KeyNotPresent_ReturnsCorrectIndex()
+        {
+            var array = new[] { 1, 2, 4, 5 };
+            var index = GallopingStrategy<int>.GallopLeft(array, 3, 0, array.Length, comparer);
+            Assert.That(index, Is.EqualTo(2));
+        }
+
+        [Test]
+        public void GallopLeft_KeyLessThanAll_ReturnsZero()
+        {
+            var array = new[] { 2, 3, 4, 5 };
+            var index = GallopingStrategy<int>.GallopLeft(array, 1, 0, array.Length, comparer);
+            Assert.That(index, Is.EqualTo(0));
+        }
+
+        [Test]
+        public void GallopLeft_KeyGreaterThanAll_ReturnsLength()
+        {
+            var array = new[] { 1, 2, 3, 4 };
+            var index = GallopingStrategy<int>.GallopLeft(array, 5, 0, array.Length, comparer);
+            Assert.That(index, Is.EqualTo(array.Length));
+        }
+
+        [Test]
+        public void GallopRight_KeyPresent_ReturnsCorrectIndex()
+        {
+            var array = new[] { 1, 2, 3, 4, 5 };
+            var index = GallopingStrategy<int>.GallopRight(array, 3, 0, array.Length, comparer);
+            Assert.That(index, Is.EqualTo(3));
+        }
+
+        [Test]
+        public void GallopRight_KeyNotPresent_ReturnsCorrectIndex()
+        {
+            var array = new[] { 1, 2, 4, 5 };
+            var index = GallopingStrategy<int>.GallopRight(array, 3, 0, array.Length, comparer);
+            Assert.That(index, Is.EqualTo(2));
+        }
+
+        [Test]
+        public void GallopRight_KeyLessThanAll_ReturnsZero()
+        {
+            var array = new[] { 2, 3, 4, 5 };
+            var index = GallopingStrategy<int>.GallopRight(array, 1, 0, array.Length, comparer);
+            Assert.That(index, Is.EqualTo(0));
+        }
+
+        [Test]
+        public void GallopRight_KeyGreaterThanAll_ReturnsLength()
+        {
+            var array = new[] { 1, 2, 3, 4 };
+            var index = GallopingStrategy<int>.GallopRight(array, 5, 0, array.Length, comparer);
+            Assert.That(index, Is.EqualTo(array.Length));
+        }
+
+        [Test]
+        public void GallopLeft_EmptyArray_ReturnsZero()
+        {
+            var array = new int[] { };
+            var index = GallopingStrategy<int>.GallopLeft(array, 1, 0, array.Length, comparer);
+            Assert.That(index, Is.EqualTo(0));
+        }
+
+        [Test]
+        public void GallopRight_EmptyArray_ReturnsZero()
+        {
+            var array = new int[] { };
+            var index = GallopingStrategy<int>.GallopRight(array, 1, 0, array.Length, comparer);
+            Assert.That(index, Is.EqualTo(0));
+        }
+    }
+}
diff --git a/Algorithms/Sorters/Comparison/TimSorter.cs b/Algorithms/Sorters/Comparison/TimSorter.cs
@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using Algorithms.Sorters.Utils;
 
 namespace Algorithms.Sorters.Comparison;
 
@@ -270,105 +271,6 @@ private int CountRunAndMakeAscending(T[] array, int start)
         return runHi - start;
     }
 
-    /// <summary>
-    /// Find the position in the array that a key should fit to the left of where it currently sits.
-    /// </summary>
-    /// <param name="array">Array to search.</param>
-    /// <param name="key">Key to place in the array.</param>
-    /// <param name="i">Base index for the key.</param>
-    /// <param name="len">Length of the chunk to run through.</param>
-    /// <param name="hint">Initial starting position to start from.</param>
-    /// <returns>Offset for the key's location.</returns>
-    private int GallopLeft(T[] array, T key, int i, int len, int hint)
-    {
-        var (offset, lastOfs) = comparer.Compare(key, array[i + hint]) > 0
-            ? RightRun(array, key, i, len, hint, 0)
-            : LeftRun(array, key, i, hint, 1);
-
-        return FinalOffset(array, key, i, offset, lastOfs, 1);
-    }
-
-    /// <summary>
-    /// Find the position in the array that a key should fit to the right of where it currently sits.
-    /// </summary>
-    /// <param name="array">Array to search.</param>
-    /// <param name="key">Key to place in the array.</param>
-    /// <param name="i">Base index for the key.</param>
-    /// <param name="len">Length of the chunk to run through.</param>
-    /// <param name="hint">Initial starting position to start from.</param>
-    /// <returns>Offset for the key's location.</returns>
-    private int GallopRight(T[] array, T key, int i, int len, int hint)
-    {
-        var (offset, lastOfs) = comparer.Compare(key, array[i + hint]) < 0
-            ? LeftRun(array, key, i, hint, 0)
-            : RightRun(array, key, i, len, hint, -1);
-
-        return FinalOffset(array, key, i, offset, lastOfs, 0);
-    }
-
-    private (int offset, int lastOfs) LeftRun(T[] array, T key, int i, int hint, int lt)
-    {
-        var maxOfs = hint + 1;
-        var (offset, tmp) = (1, 0);
-
-        while (offset < maxOfs && comparer.Compare(key, array[i + hint - offset]) < lt)
-        {
-            tmp = offset;
-            offset = BoundLeftShift(offset);
-        }
-
-        if (offset > maxOfs)
-        {
-            offset = maxOfs;
-        }
-
-        var lastOfs = hint - offset;
-        offset = hint - tmp;
-
-        return (offset, lastOfs);
-    }
-
-    private (int offset, int lastOfs) RightRun(T[] array, T key, int i, int len, int hint, int gt)
-    {
-        var (offset, lastOfs) = (1, 0);
-        var maxOfs = len - hint;
-        while (offset < maxOfs && comparer.Compare(key, array[i + hint + offset]) > gt)
-        {
-            lastOfs = offset;
-            offset = BoundLeftShift(offset);
-        }
-
-        if (offset > maxOfs)
-        {
-            offset = maxOfs;
-        }
-
-        offset += hint;
-        lastOfs += hint;
-
-        return (offset, lastOfs);
-    }
-
-    private int FinalOffset(T[] array, T key, int i, int offset, int lastOfs, int lt)
-    {
-        lastOfs++;
-        while (lastOfs < offset)
-        {
-            var m = lastOfs + (int)((uint)(offset - lastOfs) >> 1);
-
-            if (comparer.Compare(key, array[i + m]) < lt)
-            {
-                offset = m;
-            }
-            else
-            {
-                lastOfs = m + 1;
-            }
-        }
-
-        return offset;
-    }
-
     /// <summary>
     /// Sorts the specified portion of the specified array using a binary
     /// insertion sort. It requires O(n log n) compares, but O(n^2) data movement.
@@ -470,7 +372,7 @@ private void MergeAt(T[] array, int index)
 
         stackSize--;
 
-        var k = GallopRight(array, array[baseB], baseA, lenA, 0);
+        var k = GallopingStrategy<T>.GallopRight(array, array[baseB], baseA, lenA, comparer);
 
         baseA += k;
         lenA -= k;
@@ -480,7 +382,7 @@ private void MergeAt(T[] array, int index)
             return;
         }
 
-        lenB = GallopLeft(array, array[baseA + lenA - 1], baseB, lenB, lenB - 1);
+        lenB = GallopingStrategy<T>.GallopLeft(array, array[baseA + lenA - 1], baseB, lenB, comparer);
 
         if (lenB <= 0)
         {
@@ -595,7 +497,7 @@ private bool StableMerge(TimChunk<T> left, TimChunk<T> right, ref int dest, int
 
     private bool GallopMerge(TimChunk<T> left, TimChunk<T> right, ref int dest)
     {
-        left.Wins = GallopRight(left.Array, right.Array[right.Index], left.Index, left.Remaining, 0);
+        left.Wins = GallopingStrategy<T>.GallopRight(left.Array, right.Array[right.Index], left.Index, left.Remaining, comparer);
         if (left.Wins != 0)
         {
             Array.Copy(left.Array, left.Index, right.Array, dest, left.Wins);
@@ -614,7 +516,7 @@ private bool GallopMerge(TimChunk<T> left, TimChunk<T> right, ref int dest)
             return true;
         }
 
-        right.Wins = GallopLeft(right.Array, left.Array[left.Index], right.Index, right.Remaining, 0);
+        right.Wins = GallopingStrategy<T>.GallopLeft(right.Array, left.Array[left.Index], right.Index, right.Remaining, comparer);
         if (right.Wins != 0)
         {
             Array.Copy(right.Array, right.Index, right.Array, dest, right.Wins);
diff --git a/Algorithms/Sorters/Utils/GallopingStrategy.cs b/Algorithms/Sorters/Utils/GallopingStrategy.cs
@@ -0,0 +1,106 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Algorithms.Sorters.Utils
+{
+    public static class GallopingStrategy<T>
+    {
+        public static int GallopLeft(T[] array, T key, int baseIndex, int length, IComparer<T> comparer)
+        {
+            if (array.Length == 0)
+            {
+                return 0;
+            }
+
+            var (offset, lastOfs) = comparer.Compare(key, array[baseIndex]) > 0
+           ? RightRun(array, key, baseIndex, length, 0, comparer)
+           : LeftRun(array, key, baseIndex, 0, comparer);
+
+            return FinalOffset(array, key, baseIndex, offset, lastOfs, 1, comparer);
+        }
+
+        public static int GallopRight(T[] array, T key, int baseIndex, int length, IComparer<T> comparer)
+        {
+            if (array.Length == 0)
+            {
+                return 0;
+            }
+
+            var (offset, lastOfs) = comparer.Compare(key, array[baseIndex]) < 0
+            ? LeftRun(array, key, baseIndex, length, comparer)
+            : RightRun(array, key, baseIndex, length, 0, comparer);
+
+            return FinalOffset(array, key, baseIndex, offset, lastOfs, 0, comparer);
+        }
+
+        private static (int offset, int lastOfs) LeftRun(T[] array, T key, int baseIndex, int hint, IComparer<T> comparer)
+        {
+            var maxOfs = hint + 1;
+            var (offset, tmp) = (1, 0);
+
+            while (offset < maxOfs && comparer.Compare(key, array[baseIndex + hint - offset]) < 0)
+            {
+                tmp = offset;
+                offset = BoundLeftShift(offset);
+            }
+
+            if (offset > maxOfs)
+            {
+                offset = maxOfs;
+            }
+
+            var lastOfs = hint - offset;
+            offset = hint - tmp;
+
+            return (offset, lastOfs);
+        }
+
+        private static (int offset, int lastOfs) RightRun(T[] array, T key, int baseIndex, int len, int hint, IComparer<T> comparer)
+        {
+            var (offset, lastOfs) = (1, 0);
+            var maxOfs = len - hint;
+            while (offset < maxOfs && comparer.Compare(key, array[baseIndex + hint + offset]) > 0)
+            {
+                lastOfs = offset;
+                offset = BoundLeftShift(offset);
+            }
+
+            if (offset > maxOfs)
+            {
+                offset = maxOfs;
+            }
+
+            offset += hint;
+            lastOfs += hint;
+
+            return (offset, lastOfs);
+        }
+
+        private static int FinalOffset(T[] array, T key, int baseIndex, int offset, int lastOfs, int lt, IComparer<T> comparer)
+        {
+            lastOfs++;
+            while (lastOfs < offset)
+            {
+                var m = lastOfs + (int)((uint)(offset - lastOfs) >> 1);
+
+                if (comparer.Compare(key, array[baseIndex + m]) < lt)
+                {
+                    offset = m;
+                }
+                else
+                {
+                    lastOfs = m + 1;
+                }
+            }
+
+            return offset;
+        }
+
+        private static int BoundLeftShift(int shiftable) => (shiftable << 1) < 0
+                ? (shiftable << 1) + 1
+                : int.MaxValue;
+    }
+}
