Removed redundant parameters and cleaned up code

-The "base case" where the count of `collection` is 2 will already be handled properly if we let the collection be split and merged. There's no need to explicitly write a case for it.
-The parameters `startIndex` and `endIndex` are unneeded. `startIndex` will *always* be 0 and `endIndex` will *always* be `collection.Count - 1`. It seems someone started to write an in-place index-based MergeSort, but switched to one that splits and creates new Lists.
-Cleaned up the for loop in Merge with the strange break in the else of the if. Updated the loop condition so that we don't even have to worry about that.
-At most one of the two split Lists will still have items after the initial loop in Merge (after all, we only stop looping after we've exhausted one List, so that List can't have any more items). As such, there's no need for separate right and left index variables. Cleaned up the ending loops with this in mind.

Author: scohe001

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;