Split sorters into comparison and integer (TheAlgorithms#119)

* Split sorters into comparison and integer

* Update README.md

Algorithms.Tests/Compressors/HuffmanCompressorTests.cs

@@ -1,5 +1,5 @@
 using Algorithms.DataCompression;
-using Algorithms.Sorters;
+using Algorithms.Sorters.Comparison;
 using NUnit.Framework;
 using NUnit.Framework.Internal;
 

Algorithms.Tests/Helpers/RandomHelper.cs

@@ -11,7 +11,7 @@ public static (int[] correctArray, int[] testArray) GetArrays(int n)
 
             for (var i = 0; i < n; i++)
             {
-                var t = TestContext.CurrentContext.Random.Next(0, 1000);
+                var t = TestContext.CurrentContext.Random.Next(1_000_000);
                 testArr[i] = t;
                 correctArray[i] = t;
             }

Algorithms.Tests/Sorters/BinaryInsertionSorterTests.cs → Algorithms.Tests/Sorters/Comparison/BinaryInsertionSorterTests.cs

@@ -1,9 +1,9 @@
 using System;
-using Algorithms.Sorters;
+using Algorithms.Sorters.Comparison;
 using Algorithms.Tests.Helpers;
 using NUnit.Framework;
 
-namespace Algorithms.Tests.Sorters
+namespace Algorithms.Tests.Sorters.Comparison
 {
     public static class BinaryInsertionSorterTests
     {

Algorithms.Tests/Sorters/BogoSorterTests.cs → Algorithms.Tests/Sorters/Comparison/BogoSorterTests.cs

@@ -1,9 +1,9 @@
 using System;
-using Algorithms.Sorters;
+using Algorithms.Sorters.Comparison;
 using Algorithms.Tests.Helpers;
 using NUnit.Framework;
 
-namespace Algorithms.Tests.Sorters
+namespace Algorithms.Tests.Sorters.Comparison
 {
     public static class BogoSorterTests
     {

Algorithms.Tests/Sorters/BubbleSorterTests.cs → Algorithms.Tests/Sorters/Comparison/BubbleSorterTests.cs

@@ -1,11 +1,11 @@
 using System;
 
-using Algorithms.Sorters;
+using Algorithms.Sorters.Comparison;
 using Algorithms.Tests.Helpers;
 
 using NUnit.Framework;
 
-namespace Algorithms.Tests.Sorters
+namespace Algorithms.Tests.Sorters.Comparison
 {
     public static class BubbleSorterTests
     {

Algorithms.Tests/Sorters/CocktailSorterTests.cs → Algorithms.Tests/Sorters/Comparison/CocktailSorterTests.cs

@@ -1,11 +1,11 @@
 using System;
 
-using Algorithms.Sorters;
+using Algorithms.Sorters.Comparison;
 using Algorithms.Tests.Helpers;
 
 using NUnit.Framework;
 
-namespace Algorithms.Tests.Sorters
+namespace Algorithms.Tests.Sorters.Comparison
 {
     public static class CocktailSorterTests
     {

Algorithms.Tests/Sorters/CycleSorterTests.cs → Algorithms.Tests/Sorters/Comparison/CycleSorterTests.cs

@@ -1,9 +1,9 @@
 using System;
-using Algorithms.Sorters;
+using Algorithms.Sorters.Comparison;
 using Algorithms.Tests.Helpers;
 using NUnit.Framework;
 
-namespace Algorithms.Tests.Sorters
+namespace Algorithms.Tests.Sorters.Comparison
 {
     public static class CycleSorterTests
     {

Algorithms.Tests/Sorters/HeapSorterTests.cs → Algorithms.Tests/Sorters/Comparison/HeapSorterTests.cs

@@ -1,9 +1,9 @@
 using System;
-using Algorithms.Sorters;
+using Algorithms.Sorters.Comparison;
 using Algorithms.Tests.Helpers;
 using NUnit.Framework;
 
-namespace Algorithms.Tests.Sorters
+namespace Algorithms.Tests.Sorters.Comparison
 {
     public static class HeapSorterTests
     {

Algorithms.Tests/Sorters/InsertionSorterTests.cs → Algorithms.Tests/Sorters/Comparison/InsertionSorterTests.cs

@@ -1,9 +1,9 @@
 using System;
-using Algorithms.Sorters;
+using Algorithms.Sorters.Comparison;
 using Algorithms.Tests.Helpers;
 using NUnit.Framework;
 
-namespace Algorithms.Tests.Sorters
+namespace Algorithms.Tests.Sorters.Comparison
 {
     public static class InsertionSorterTests
     {

Algorithms.Tests/Sorters/MergeSorterTests.cs → Algorithms.Tests/Sorters/Comparison/MergeSorterTests.cs

@@ -1,9 +1,9 @@
 using System;
-using Algorithms.Sorters;
+using Algorithms.Sorters.Comparison;
 using Algorithms.Tests.Helpers;
 using NUnit.Framework;
 
-namespace Algorithms.Tests.Sorters
+namespace Algorithms.Tests.Sorters.Comparison
 {
     /// <summary>
     /// Class for testing merge sorter algorithm.

Algorithms.Tests/Sorters/PancakeSorterTests.cs → Algorithms.Tests/Sorters/Comparison/PancakeSorterTests.cs

@@ -1,9 +1,9 @@
 using System;
-using Algorithms.Sorters;
+using Algorithms.Sorters.Comparison;
 using Algorithms.Tests.Helpers;
 using NUnit.Framework;
 
-namespace Algorithms.Tests.Sorters
+namespace Algorithms.Tests.Sorters.Comparison
 {
     public static class PancakeSorterTests
     {

Algorithms.Tests/Sorters/QuickSorterTests.cs → Algorithms.Tests/Sorters/Comparison/QuickSorterTests.cs

@@ -1,9 +1,9 @@
 using System;
-using Algorithms.Sorters;
+using Algorithms.Sorters.Comparison;
 using Algorithms.Tests.Helpers;
 using NUnit.Framework;
 
-namespace Algorithms.Tests.Sorters
+namespace Algorithms.Tests.Sorters.Comparison
 {
     public static class QuickSorterTests
     {

Algorithms.Tests/Sorters/SelectionSorterTests.cs → Algorithms.Tests/Sorters/Comparison/SelectionSorterTests.cs

@@ -1,9 +1,9 @@
 using System;
-using Algorithms.Sorters;
+using Algorithms.Sorters.Comparison;
 using Algorithms.Tests.Helpers;
 using NUnit.Framework;
 
-namespace Algorithms.Tests.Sorters
+namespace Algorithms.Tests.Sorters.Comparison
 {
     public static class SelectionSorterTests
     {

Algorithms.Tests/Sorters/ShellSorterTests.cs → Algorithms.Tests/Sorters/Comparison/ShellSorterTests.cs

@@ -1,9 +1,9 @@
 using System;
-using Algorithms.Sorters;
+using Algorithms.Sorters.Comparison;
 using Algorithms.Tests.Helpers;
 using NUnit.Framework;
 
-namespace Algorithms.Tests.Sorters
+namespace Algorithms.Tests.Sorters.Comparison
 {
     public static class ShellSorterTests
     {

Algorithms.Tests/Sorters/BucketSorterTests.cs → Algorithms.Tests/Sorters/Integer/BucketSorterTests.cs

@@ -1,11 +1,10 @@
 using System;
-
-using Algorithms.Sorters;
+using Algorithms.Sorters.Integer;
 using Algorithms.Tests.Helpers;
 
 using NUnit.Framework;
 
-namespace Algorithms.Tests.Sorters
+namespace Algorithms.Tests.Sorters.Integer
 {
     public static class BucketSorterTests
     {
@@ -14,11 +13,10 @@ public static void ArraySorted([Random(0, 1000, 1000, Distinct = true)]int n)
         {
             // Arrange
             var sorter = new BucketSorter();
-            var intComparer = new IntComparer();
             var (correctArray, testArray) = RandomHelper.GetArrays(n);
 
             // Act
-            sorter.Sort(testArray, intComparer);
+            sorter.Sort(testArray);
             Array.Sort(correctArray);
 
             // Assert

Algorithms.Tests/Sorters/CountingSorterTests.cs → Algorithms.Tests/Sorters/Integer/CountingSorterTests.cs

@@ -1,20 +1,21 @@
 using System;
-using Algorithms.Sorters;
+using Algorithms.Sorters.Integer;
 using Algorithms.Tests.Helpers;
 using NUnit.Framework;
 
-namespace Algorithms.Tests.Sorters
+namespace Algorithms.Tests.Sorters.Integer
 {
     public static class CountingSorterTests
     {
         [Test]
         public static void SortsArray([Random(0, 10000, 100, Distinct = true)]int n)
         {
             // Arrange
+            var sorter = new CountingSorter();
             var (correctArray, testArray) = RandomHelper.GetArrays(n);
 
             // Act
-            CountingSorter.Sort(testArray);
+            sorter.Sort(testArray);
             Array.Sort(correctArray);
 
             // Assert

Algorithms.Tests/Sorters/RadixSorterTests.cs → Algorithms.Tests/Sorters/Integer/RadixSorterTests.cs

@@ -1,23 +1,22 @@
 using System;
-
-using Algorithms.Sorters;
+using Algorithms.Sorters.Integer;
 using Algorithms.Tests.Helpers;
 
 using NUnit.Framework;
 
-namespace Algorithms.Tests.Sorters
+namespace Algorithms.Tests.Sorters.Integer
 {
     public static class RadixSorterTests
     {
         [Test]
         public static void SortsArray([Random(0, 1000, 100, Distinct = true)]int n)
         {
             // Arrange
-            const int bits = 4;
+            var sorter = new RadixSorter();
             var (correctArray, testArray) = RandomHelper.GetArrays(n);
 
             // Act
-            RadixSorter.Sort(testArray, bits);
+            sorter.Sort(testArray);
             Array.Sort(correctArray);
 
             // Assert

Algorithms.Tests/Sorters/MsdRadixSorterTests.cs → Algorithms.Tests/Sorters/String/MsdRadixStringSorterTests.cs

@@ -1,20 +1,20 @@
 using System;
-using Algorithms.Sorters;
+using Algorithms.Sorters.String;
 using Algorithms.Tests.Helpers;
 using NUnit.Framework;
 
-namespace Algorithms.Tests.Sorters
+namespace Algorithms.Tests.Sorters.String
 {
     /// <summary>
     /// Class for testing MSD radix sorter algorithm.
     /// </summary>
-    public static class MsdRadixSorterTests
+    public static class MsdRadixStringSorterTests
     {
         [Test]
         public static void ArraySorted([Random(2, 1000, 100, Distinct = true)]int n)
         {
             // Arrange 
-            var sorter = new MsdRadixSorter();
+            var sorter = new MsdRadixStringSorter();
             var (correctArray, testArray) = RandomHelper.GetStringArrays(n, 100, false);
 
             // Act

Algorithms/DataCompression/HuffmanCompressor.cs

@@ -1,7 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
-using Algorithms.Sorters;
+using Algorithms.Sorters.Comparison;
 
 namespace Algorithms.DataCompression
 {
@@ -11,15 +11,15 @@ namespace Algorithms.DataCompression
     public class HuffmanCompressor
     {
         // TODO: Use partial sorter
-        private readonly ISorter<ListNode> sorter;
+        private readonly IComparisonSorter<ListNode> sorter;
         private readonly Translator translator;
 
         /// <summary>
         /// Initializes a new instance of the <see cref="HuffmanCompressor"/> class.
         /// </summary>
         /// <param name="sorter">Sorter to use for compression.</param>
         /// <param name="translator">Translator.</param>
-        public HuffmanCompressor(ISorter<ListNode> sorter, Translator translator)
+        public HuffmanCompressor(IComparisonSorter<ListNode> sorter, Translator translator)
         {
             this.sorter = sorter;
             this.translator = translator;

Algorithms/Sorters/BinaryInsertionSorter.cs → Algorithms/Sorters/Comparison/BinaryInsertionSorter.cs

@@ -1,13 +1,13 @@
 using System;
 using System.Collections.Generic;
 
-namespace Algorithms.Sorters
+namespace Algorithms.Sorters.Comparison
 {
     /// <summary>
     /// TODO.
     /// </summary>
     /// <typeparam name="T">TODO. 2.</typeparam>
-    public class BinaryInsertionSorter<T> : ISorter<T>
+    public class BinaryInsertionSorter<T> : IComparisonSorter<T>
     {
         /// <summary>
         /// Sorts array using specified comparer,

Algorithms/Sorters/BogoSorter.cs → Algorithms/Sorters/Comparison/BogoSorter.cs

@@ -1,13 +1,13 @@
 using System;
 using System.Collections.Generic;
 
-namespace Algorithms.Sorters
+namespace Algorithms.Sorters.Comparison
 {
     /// <summary>
     /// Class that implements bogo sort algorithm.
     /// </summary>
     /// <typeparam name="T">Type of array element.</typeparam>
-    public class BogoSorter<T> : ISorter<T>
+    public class BogoSorter<T> : IComparisonSorter<T>
     {
         private readonly Random random = new Random();
 

Algorithms/Sorters/BubbleSorter.cs → Algorithms/Sorters/Comparison/BubbleSorter.cs

@@ -1,12 +1,12 @@
 using System.Collections.Generic;
 
-namespace Algorithms.Sorters
+namespace Algorithms.Sorters.Comparison
 {
     /// <summary>
     /// Class that implements bubble sort algorithm.
     /// </summary>
     /// <typeparam name="T">Type of array element.</typeparam>
-    public class BubbleSorter<T> : ISorter<T>
+    public class BubbleSorter<T> : IComparisonSorter<T>
     {
         /// <summary>
         /// Sorts array using specified comparer,

Algorithms/Sorters/CocktailSorter.cs → Algorithms/Sorters/Comparison/CocktailSorter.cs

@@ -1,13 +1,13 @@
 using System.Collections.Generic;
 
-namespace Algorithms.Sorters
+namespace Algorithms.Sorters.Comparison
 {
     /// <summary>
     /// Cocktail Sort is a variation of Bubble sort, where Cocktail
     /// Sort traverses through a given array in both directions alternatively.
     /// </summary>
     /// <typeparam name="T">Array input type.</typeparam>
-    public class CocktailSorter<T> : ISorter<T>
+    public class CocktailSorter<T> : IComparisonSorter<T>
     {
         /// <summary>
         /// Sorts array using Cocktail sort algorithm.

Algorithms/Sorters/CycleSorter.cs → Algorithms/Sorters/Comparison/CycleSorter.cs

@@ -1,6 +1,6 @@
 using System.Collections.Generic;
 
-namespace Algorithms.Sorters
+namespace Algorithms.Sorters.Comparison
 {
     /// <summary>
     /// Cycle sort is an in-place, unstable sorting algorithm,
@@ -10,7 +10,7 @@ namespace Algorithms.Sorters
     /// into cycles, which can individually be rotated to give a sorted result.
     /// </summary>
     /// <typeparam name="T">Type array input.</typeparam>
-    public class CycleSorter<T> : ISorter<T>
+    public class CycleSorter<T> : IComparisonSorter<T>
     {
         /// <summary>
         /// Sorts input array using Cycle sort.

Algorithms/Sorters/HeapSorter.cs → Algorithms/Sorters/Comparison/HeapSorter.cs

@@ -1,13 +1,13 @@
 using System.Collections.Generic;
 
-namespace Algorithms.Sorters
+namespace Algorithms.Sorters.Comparison
 {
     /// <summary>
     /// Heap sort is a comparison based sorting technique
     /// based on Binary Heap data structure.
     /// </summary>
     /// <typeparam name="T">Input array type.</typeparam>
-    public class HeapSorter<T> : ISorter<T>
+    public class HeapSorter<T> : IComparisonSorter<T>
     {
         /// <summary>
         /// Sorts input array using heap sort algorithm.