Merge remote-tracking branch 'upstream/master'

Author: PatrykOlejniczak

Algorithms/Numeric/GreatestCommonDivisor.cs

@@ -1,46 +1,73 @@
-/***
- * Euclidean Algorithm to find the greatest common divisor of two numbers.
- * 
- */
-
+using System;
 
 namespace Algorithms.Numeric
 {
     public static class GreatestCommonDivisor
     {
         /// <summary>
-        /// Finds and returns the greatest common divisor of two numbers
+        ///     Returns the greatest common divisor of two numbers using Euclidean Algorithm.
         /// </summary>
-        public static uint FindGCD(uint a, uint b)
+        public static int FindGCDEuclidean(int a, int b)
         {
+            a = Math.Abs(a);
+            b = Math.Abs(b);
+
             if (a == 0)
                 return b;
             if (b == 0)
                 return a;
+            if (a == b)
+                return a;
 
-            uint _a = a, _b = b;
-            
-            //Bitwise operator '&' works on individual bits of each value
-            //result is 0 or 1
-            //it works like a modulus operator '%' but is more efficient
-            uint r = _a & _b;
+            return Euclidean(a, b);
+        }
 
-            while(r != 0)
-            {
-                _a = _b;
-                _b = r;
-                r = _a & _b;
-            }
+        private static int Euclidean(int a, int b)
+        {
+            if (b == 0)
+                return a;
 
-            return _b;
+            return Euclidean(b, a % b);
         }
 
         /// <summary>
-        /// Determines given two numbers are relatively prime
+        ///     Returns the greatest common divisor of two numbers using Stein Algorithm.
         /// </summary>
-        public static bool IsRelativelyPrime(uint a, uint b)
+        public static int FindGCDStein(int a, int b)
+        {
+            a = Math.Abs(a);
+            b = Math.Abs(b);
+
+            return Stein(a, b);
+        }
+
+        private static int Stein(int a, int b)
         {
-            return FindGCD(a, b) == 1;
+            if (a == 0)
+                return b;
+            if (b == 0)
+                return a;
+            if (a == b)
+                return a;
+
+            if ((~a & 1) == 1)
+            {
+                if ((b & 1) == 1)
+                {
+                    return Stein(a >> 1, b);
+                }
+                else
+                {
+                    return Stein(a >> 1, b >> 1) << 1;
+                }
+            }
+
+            if ((~b & 1) == 1)
+            {
+                return Stein(a, b >> 1);
+            }
+
+            return a > b ? Stein((a - b) >> 1, b) : Stein(a, (b - a) >> 1);
         }
     }
 }

Algorithms/Numeric/SieveOfAtkin.cs

@@ -0,0 +1,73 @@
+using System.Collections.Generic;
+using System.Reflection.Metadata.Ecma335;
+using System.Threading.Tasks;
+
+/***
+* Generates all prime numbers up to a given number
+* Wikipedia: https://en.wikipedia.org/wiki/Sieve_of_Atkin
+*/
+
+
+namespace Algorithms.Numeric
+{
+    public static class SieveOfAtkin
+    {
+        /// <summary>
+        /// Calculate primes up to a given number
+        /// </summary>
+        public static List<int> GeneratePrimesUpTo(int max)
+        {
+            if (max == 2)
+            {
+                return new List<int>() { 2 };
+            }
+
+            if (max < 2)
+            {
+                return new List<int>();
+            }
+
+            var isPrime = new bool[max + 1];
+            var sqrt = (int)System.Math.Sqrt(max);
+
+            Parallel.For(1, sqrt, x =>
+            {
+                var xx = x * x;
+                for (var y = 1; y <= sqrt; y++)
+                {
+                    var yy = y * y;
+                    var n = 4 * xx + yy;
+                    if (n <= max && (n % 12 == 1 || n % 12 == 5))
+                        isPrime[n] ^= true;
+
+                    n = 3 * xx + yy;
+                    if (n <= max && n % 12 == 7)
+                        isPrime[n] ^= true;
+
+                    n = 3 * xx - yy;
+                    if (x > y && n <= max && n % 12 == 11)
+                        isPrime[n] ^= true;
+                }
+            });
+
+            var primes = new List<int>() { 2, 3 };
+            for (var n = 5; n <= sqrt; n++)
+            {
+                if (isPrime[n])
+                {
+                    primes.Add(n);
+                    var nn = n * n;
+                    for (var k = nn; k <= max; k += nn)
+                        isPrime[k] = false;
+                }
+            }
+
+            for (var n = sqrt + 1; n <= max; n++)
+                if (isPrime[n])
+                    primes.Add(n);
+
+            return primes;
+        }
+
+    }
+}

Algorithms/Numeric/SieveOfEratosthenes.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Linq;
 
 /***
 * Generates all prime numbers up to a given number
@@ -14,43 +15,43 @@ public static class SieveOfEratosthenes
         /// <summary>
         /// Calculate primes up to a given number
         /// </summary>
-        public static List<int> GeneratePrimesUpTo(int x)
+        public static IEnumerable<int> GeneratePrimesUpTo(int x)
         {
 
-            //The list of primes that will be returned
-            List<int> primesList = new List<int>();
+            //The hash of primes that will be returned
+            var primes = new HashSet<int>();
 
             //Returns an empty list if x is a value under 2
             if (x < 2)
             {
-                return primesList;
+                return primes.ToList();
             }
 
-            //Adds every number between 2 and x to the list
+            //Adds every number between 2 and x to the hashset
             for (int i = 2; i <= x; i++)
             {
-                primesList.Add(i);
+                primes.Add(i);
             }
 
-            //integer that all multiples of will be removed from the list
+            //integer that all multiples of will be removed from the hashset
             int removeMultiplesOf;
 
-            //Finds the next number in the list that hasn't been removed and removes all multiples of that number 
-            //from the list
+            //Finds the next number that hasn't been removed and removes all multiples of that number 
+            //from the hashset
             for (int i = 2; i <= Math.Sqrt(x); i++)
             {
-                if (primesList.Contains(i))
+                if (primes.Contains(i))
                 {
                     removeMultiplesOf = i;
-                    for (int j = removeMultiplesOf*removeMultiplesOf; j <= x; j += removeMultiplesOf)
+                    for (int j = removeMultiplesOf * removeMultiplesOf; j <= x; j += removeMultiplesOf)
                     {
-                        primesList.Remove(j);
+                        primes.Remove(j);
                     }
                 }
             }
 
             //The list of primes is returned
-            return primesList;
+            return primes.ToList();
         }
 
     }

Algorithms/Sorting/MergeSorter.cs

@@ -11,37 +11,27 @@ public static List<T> MergeSort<T>(this List<T> collection, Comparer<T> comparer
         {
             comparer = comparer ?? Comparer<T>.Default;
 
-            return InternalMergeSort(collection, 0, collection.Count - 1, comparer);
+            return InternalMergeSort(collection, comparer);
         }
 
 
         //
         // Private static method
         // Implements the recursive merge-sort algorithm
-        private static List<T> InternalMergeSort<T>(List<T> collection, int startIndex, int endIndex, Comparer<T> comparer)
+        private static List<T> InternalMergeSort<T>(List<T> collection, Comparer<T> comparer)
         {
             if (collection.Count < 2)
             {
                 return collection;
             }
 
-            if (collection.Count == 2)
-            {
-                if (comparer.Compare(collection[endIndex], collection[startIndex]) < 0)
-                {
-                    collection.Swap(endIndex, startIndex);
-                }
-
-                return collection;
-            }
-
             int midIndex = collection.Count / 2;
 
-            var leftCollection = collection.GetRange(startIndex, midIndex);
-            var rightCollection = collection.GetRange(midIndex, (endIndex - midIndex) + 1);
+            var leftCollection = collection.GetRange(0, midIndex);
+            var rightCollection = collection.GetRange(midIndex, collection.Count - midIndex);
 
-            leftCollection = InternalMergeSort<T>(leftCollection, 0, leftCollection.Count - 1, comparer);
-            rightCollection = InternalMergeSort<T>(rightCollection, 0, rightCollection.Count - 1, comparer);
+            leftCollection = InternalMergeSort<T>(leftCollection, comparer);
+            rightCollection = InternalMergeSort<T>(rightCollection, comparer);
 
             return InternalMerge<T>(leftCollection, rightCollection, comparer);
         }
@@ -59,42 +49,31 @@ private static List<T> InternalMerge<T>(List<T> leftCollection, List<T> rightCol
 
             List<T> result = new List<T>(length);
 
-            for (index = 0; index < length; ++index)
+            for (index = 0; right < rightCollection.Count && left < leftCollection.Count; ++index)
             {
-                if (right < rightCollection.Count && comparer.Compare(rightCollection[right], leftCollection[left]) <= 0) // rightElement <= leftElement
+                if (comparer.Compare(rightCollection[right], leftCollection[left]) <= 0) // rightElement <= leftElement
                 {
                     //resultArray.Add(rightCollection[right]);
-                    result.Insert(index, rightCollection[right]);
-                    right++;
+                    result.Insert(index, rightCollection[right++]);
                 }
                 else
                 {
                     //result.Add(leftCollection[left]);
-                    result.Insert(index, leftCollection[left]);
-                    left++;
-
-                    if (left == leftCollection.Count)
-                        break;
+                    result.Insert(index, leftCollection[left++]);
                 }
             }
 
             //
-            // Either one might have elements left
-            int rIndex = index + 1;
-            int lIndex = index + 1;
-
+            // At most one of left and right might still have elements left
+            
             while (right < rightCollection.Count)
             {
-                result.Insert(rIndex, rightCollection[right]);
-                rIndex++;
-                right++;
+                result.Insert(index++, rightCollection[right++]);
             }
 
             while (left < leftCollection.Count)
             {
-                result.Insert(lIndex, leftCollection[left]);
-                lIndex++;
-                left++;
+                result.Insert(index++, leftCollection[left++]);
             }
 
             return result;

DataStructures/Heaps/BinaryMaxHeap.cs

@@ -44,6 +44,20 @@ private void _buildMaxHeap()
             }
         }
 
+        /// <summary>
+        /// Private Method. Used to restore heap condition after insertion
+        /// </summary>
+        private void _siftUp(int nodeIndex)
+        {
+            int parent = (nodeIndex - 1) / 2;
+            while (_heapComparer.Compare(_collection[nodeIndex], _collection[parent]) > 0)
+            {
+                _collection.Swap(parent, nodeIndex);
+                nodeIndex = parent;
+                parent = (nodeIndex - 1) / 2;
+            }
+        }
+
         /// <summary>
         /// Private Method. Used in Building a Max Heap.
         /// </summary>
@@ -110,11 +124,10 @@ public T this[int index]
 
                 _collection[index] = value;
 
-                if (_heapComparer.Compare(_collection[index], _collection[0]) >= 0) // greater than or equal to max
-                {
-                    _collection.Swap(0, index);
-                    _buildMaxHeap();
-                }
+                if (index != 0 && _heapComparer.Compare(_collection[index], _collection[(index - 1) / 2]) > 0) // greater than or equal to max
+                    _siftUp(index);
+                else
+                    _maxHeapify(index, _collection.Count - 1);
             }
         }
 
@@ -144,14 +157,10 @@ public void Initialize(IList<T> newCollection)
         /// </summary>
         public void Add(T heapKey)
         {
-            if (IsEmpty)
+            _collection.Add(heapKey);
+            if (!IsEmpty)
             {
-                _collection.Add(heapKey);
-            }
-            else
-            {
-                _collection.Add(heapKey);
-                _buildMaxHeap();
+                _siftUp(_collection.Count - 1);
             }
         }