static void Main()
{
Console.Write("Generating array to sort: ");
int[] arrayToSort = new int[MAX_ARRAY_SIZE];
var rGen = new Random();
for (int i = 0; i < MAX_ARRAY_SIZE; i++)
{
var progressString = $"{i + 1}/{MAX_ARRAY_SIZE}";
Console.Write(progressString);
Console.SetCursorPosition(Console.CursorLeft - progressString.Length, Console.CursorTop);
arrayToSort[i] = rGen.Next(0, MAX_ARRAY_SIZE);
}
var _bubbleSorter = new BubbleSorter <int>();
var _mergeSorter = new MergeSorter <int>();
var _insertionSorter = new InsertionSorter <int>();
BigInteger totalMs = 0;
Console.SetCursorPosition(0, Console.CursorTop + 2);
totalMs += TestIntegersArraySortingMethod("Bubble sorting", _bubbleSorter, arrayToSort);
totalMs += TestIntegersArraySortingMethod("Insertion sorting", _insertionSorter, arrayToSort);
totalMs += TestIntegersArraySortingMethod("Merge sorting", _mergeSorter, arrayToSort);
Console.WriteLine($"Test completed in {totalMs} ms");
Console.SetCursorPosition(0, Console.CursorTop + 1);
Console.WriteLine("Press any key to exit");
Console.ReadKey();
}
public void TestEmptyList()
{
var sorter = new MergeSorter();
var list = new List<int> { };
sorter.Sort(list);
Assert.AreEqual(0, list.Count);
}
public static void Show()
{
int[] arr = new int[]
{
10000, 20000, 30000, 40000, 50000,
100000, 200000, 500000,
1000000, 2000000, 5000000, 10000000,
100000000
};
foreach (int i in arr)
{
Console.WriteLine("Длина массива - " + i);
int[] array = IntArrayGenerator.GenerateArray(i);
Console.WriteLine("быстрая сортировка " + ", время выполнения - " +
ActionTimeMeasurer.Measure(new Action(() =>
HoareSorter.Sort(array))));
array = IntArrayGenerator.GenerateArray(i);
Console.WriteLine("встроенная сортировка " + ", время выполнения - " +
ActionTimeMeasurer.Measure(new Action(() =>
Array.Sort(array))));
array = IntArrayGenerator.GenerateArray(i);
Console.WriteLine("сортировка слиянием " + ", время выполнения - " +
ActionTimeMeasurer.Measure(new Action(() =>
MergeSorter.Sort(array))));
GC.Collect();
Console.WriteLine();
}
Console.ReadKey();
}
public void ThrowInvalidOperationException_WhenCollectionIsEmpty()
{
var collection = new List <int>();
var sorter = new MergeSorter <int>();
Assert.Throws <InvalidOperationException>(() => sorter.Sort(collection));
}
public static void Show()
{
int[] arr = new int[]
{
100, 500,
1000, 2000, 5000
};
foreach (int i in arr)
{
Console.WriteLine("Длина массива - " + i);
string[] array = TextGenerator.GenerateText(i).Split();
Console.WriteLine("сортировка пузырьком O(n^2) " + ", время выполнения - " +
ActionTimeMeasurer.Measure(new Action(() =>
BubbleSorter.Sort(array))));
array = TextGenerator.GenerateText(i).Split();
Console.WriteLine("сортировка вставками O(log(n)) " + ", время выполнения - " +
ActionTimeMeasurer.Measure(new Action(() =>
MergeSorter.Sort(array))));
GC.Collect();
Console.WriteLine();
}
Console.ReadKey();
}
public void Test_MergeSorter_ShouldThrowExceptionWhenCollectionIsNull()
{
var sorter = new MergeSorter <int>();
var emptyCollection = new SortableCollection <int>(null);
emptyCollection.Sort(sorter);
}
public void MergeSortNullTest()
{
IList <int> arr = null;
MergeSorter <int> sorter = new MergeSorter <int>();
sorter.Sort(arr);
}
public void When_sorting(int[] input, int[] answer)
{
var sorter = new MergeSorter <int>();
var sorted = sorter.Sort(input);
Assert.Equal(sorted, answer);
}
public SorterRightVersion(string type)
{
//design pattern or strategy pattern
//кое общото (за да напавим абстракция трябва да видим общите неща!!!)
/*
* Design smell: Need to retest after chabnges
* - Old parts changed -> possible bugs;
* Ако нещо има нужда от ре-тестване значи нямаме принципа Open/Closed
*
* */
ISorterRightVersion <T> sorterStrategy = null;
if (type == "merge")
{
sorterStrategy = new MergeSorter <T>();
}
if (type == "select")
{
sorterStrategy = new SelectionSorter <T>();
}
//ако трябва да добавим нов сорт
// 1. Нов клас с имплементация на интерфейса
//
if (type == "bogo")
{
sorterStrategy = new NewSortBogo <T>();
}
sorterStrategy.Sort(new List <T>());
}
public void TestWithAnEmptyCollection()
{
List<int> collection = new List<int>();
MergeSorter<int> sorter = new MergeSorter<int>();
sorter.Sort(collection);
Assert.AreEqual(0, collection.Count);
}
static void Main(string[] args)
{
Console.WriteLine("What strategy do you want?");
var strategyName = Console.ReadLine();
var strategy = Assembly.GetExecutingAssembly()
.GetTypes()
.Where(t => (typeof(ISortingStrategy).IsAssignableFrom(t)) &&
typeof(ISortingStrategy) != t)
.First(t => t.Name.StartsWith(strategyName));
ISortingStrategy soringStrategy = (ISortingStrategy)Activator.CreateInstance(strategy);
if (strategyName == "Merge")
{
soringStrategy = new MergeSorter();
}
if (strategyName == "Merge")
{
soringStrategy = new MergeSorter();
}
if (strategyName == "Merge")
{
soringStrategy = new MergeSorter();
}
Sorter sorter = new Sorter(soringStrategy);
sorter.Sort(new List <int>());
}
public void MergeSortZeroTest()
{
IList <int> arr = new List <int>();
MergeSorter <int> sorter = new MergeSorter <int>();
sorter.Sort(arr);
}
public void ShouldCountInversions()
{
int[] testArray = { 10, 9, 8, 7, 6, 5, 4, 3, 2, 1 };
Int64 inversionCount = new MergeSorter().CountInversions(testArray, 0, testArray.Length - 1);
Assert.AreEqual(inversionCount, 45);
}
public void Sort_NullArray_ReturnArgumentException()
{
int[] array = null;
var sorter = new MergeSorter <int>();
sorter.Sort(array);
}
public void TestProperList()
{
var sorter = new MergeSorter();
var list = new List<int> { 3, 2, 1, 9, 7 };
sorter.Sort(list);
Assert.AreEqual(5, list.Count);
Assert.IsTrue(list.SequenceEqual(new List<int> { 1, 2, 3, 7, 9 }));
}
public void TestMergeSortWithOneElement()
{
ISorter<int> sorter = new MergeSorter<int>();
collection.Items = new List<int>() { 1 };
collection.Sort(sorter);
Assert.AreEqual(collection.Items[0], 1);
}
public void PassingOneItemCollection()
{
List<int> numbers = new List<int>() {1};
MergeSorter<int> sorter = new MergeSorter<int>(numbers);
List<int> sortedList = new List<int>(sorter.Sort());
Assert.AreEqual(numbers[0], sortedList[0]);
}
static void Main(string[] args)
{
int[] a = ArrayUtil.RandomIntArray(20, 100);
Console.WriteLine(ArrayUtil.ToString(a));
MergeSorter.Sort(a);
Console.WriteLine(ArrayUtil.ToString(a));
}
public void MergeSortTestWithFilledArrayEvenRecords()
{
MergeSorter<int> mergesorter = new MergeSorter<int>();
IList<int> list = new List<int>() { 9, 3, 2, 1, 4, 6, 5, 0, 8, 7 };
IList<int> sortedList = new List<int>() { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
mergesorter.Sort(list);
Assert.AreEqual(string.Join(",", sortedList), string.Join(",", list));
}
public void Sort_EmptyArray_Success()
{
var sorter = new MergeSorter <int>();
var array = new int[0];
sorter.Sort(array);
Assert.IsTrue(sorter.Ensure(array));
}
public void TestMergeSortShouldReturnCorrectElements()
{
ISorter<int> sorter = new MergeSorter<int>();
collection.Sort(sorter);
Assert.AreEqual(collection.Items[0], 0);
Assert.AreEqual(collection.Items[2], 22);
Assert.AreEqual(collection.Items[collection.Items.Count - 1], 101);
}
public void SortEmptyTest()
{
List <int> testCollection = new List <int>();
MergeSorter <int> testMergeSorter = new MergeSorter <int>();
testMergeSorter.Sort(testCollection);
Assert.AreEqual(testCollection.Count, 0);
}
/// <summary>
/// Merge sorts list of elements. Can be chosen if topDown or BottomUp by passing true or false value as argument to the method. By default it is topDown
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="collection">List of elements</param>
/// <param name="isTopDown">true or false whether is top down or bottom up</param>
private static void MergeSort <T>(IList <T> collection, bool isTopDown = true)
where T : IComparable
{
MergeSorter sorter = new MergeSorter();
var returned = sorter.SplitThenSort(collection, isTopDown);
PrintCollection(returned);
}
public static void Main()
{
List<int> numbers = new List<int>() { 1,3,4,5,1,4,6,7,3,3,6,8,9,2 };
MergeSorter<int> mergeSorter = new MergeSorter<int>(numbers);
numbers = mergeSorter.Sort();
Console.WriteLine(string.Join(",", numbers));
}
public void ShouldSortEmptyArray()
{
var sorter = new MergeSorter <int>();
int[] items = { };
sorter.MergeSort(items);
Assert.IsEmpty(items);
}
public void Given_list_1_2_3_4_and_empty_list_should_get_1_2_3_4()
{
var list1 = new[] {1, 2, 3, 4};
var list2 = new int[] {};
var sorter = new MergeSorter<int>();
var result = sorter.Merge(list1, list2, (a, b) => a.CompareTo(b)).ToList();
result.ShouldContainAllInOrder(new[] {1, 2, 3, 4});
}
public void ShouldSortTwoItems()
{
var sorter = new MergeSorter <int>();
int[] items = { 8, 3 };
sorter.MergeSort(items);
Assert.AreEqual(new int[] { 3, 8 }, items);
}
public void ShouldSortMultipleItems()
{
var sorter = new MergeSorter <int>();
int[] items = { 8, 3, 4, 12, 73, 1, 3, 4, 5 };
sorter.MergeSort(items);
Assert.AreEqual(new int[] { 1, 3, 3, 4, 4, 5, 8, 12, 73 }, items);
}
public void Sort_hugeArrayTest()
{
int[] unsortedArray_1 = GenerateArray();
int[] unsortedArray_2 = new int[1000];
unsortedArray_1.CopyTo(unsortedArray_2, 0);
Array.Sort(unsortedArray_1);
MergeSorter.Sort(unsortedArray_2);
CollectionAssert.AreEqual(unsortedArray_1, unsortedArray_2);
}
public void Given_empty_list_and_list_5_6_7_should_get_5_6_7()
{
var list1 = new int[] {};
var list2 = new[] {5, 6, 7};
var sorter = new MergeSorter<int>();
var result = sorter.Merge(list1, list2, (a, b) => a.CompareTo(b)).ToList();
result.ShouldContainAllInOrder(new[] {5, 6, 7});
}
public void Given_lists_5_6_7_and_1_2_3_4_should_get_1_2_3_4_5_6_7()
{
var list1 = new[] {5, 6, 7};
var list2 = new[] {1, 2, 3, 4};
var sorter = new MergeSorter<int>();
var result = sorter.Merge(list1, list2, (a, b) => a.CompareTo(b)).ToList();
result.ShouldContainAllInOrder(new[] {1, 2, 3, 4, 5, 6, 7});
}
public void TestingMerge6()
{
List<int> list1 = new List<int>() { 2 };
List<int> list2 = new List<int>() { 1, 4 };
MergeSorter<int> ms = new MergeSorter<int>();
var result = ms.Merge(list1, list2);
IList<int> sortedList = new List<int>() { 1, 2, 4 };
Assert.AreEqual(string.Join(",", sortedList), string.Join(",", result));
}
public void SortedNumbersTest()
{
var listToSort = new List<int> { 1, 2, 3, 4, 5 };
var sorter = new MergeSorter<int>();
var actual = sorter.Mergesorter(listToSort).ToList();
var expected = new List<int> { 1, 2, 3, 4, 5 };
CollectionAssert.AreEqual(actual, expected);
}
public async Task SortAsync_Should_Sort_Input(string input, string sortedInput)
{
var value = input;
var expectedValue = sortedInput;
var sorter = new MergeSorter();
var result = await sorter.SortAsync(value);
Assert.AreEqual(expectedValue, result);
}
public void Sort_Should_Sort_Input(string input, string sortedInput)
{
var value = input;
var expectedValue = sortedInput;
var sorter = new MergeSorter();
var result = sorter.Sort(value);
Assert.AreEqual(expectedValue, result);
}
public void TestingMerge3()
{
List<int> list1 = new List<int>() { 0, 1, 2, 3, 4, 5, 6, 7, 8 };
List<int> list2 = new List<int>() { 9 };
MergeSorter<int> ms = new MergeSorter<int>();
var result = ms.Merge(list1, list2);
IList<int> sortedList = new List<int>() { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
Assert.AreEqual(string.Join(",", sortedList), string.Join(",", result));
}
public void SimpleMergeSortTest()
{
List<int> arrayToSort = new List<int>() { 2, 5, 3, 1, 4 };
MergeSorter<int> mergeSorter = new MergeSorter<int>();
List<int> expectedArray = new List<int>() { 1, 2, 3, 4, 5 };
mergeSorter.Sort(arrayToSort);
CollectionAssert.AreEqual(expectedArray, arrayToSort);
}
public void ReversedNumberSortTest()
{
List<int> arrayToSort = new List<int>() { 5, 4, 3, 2, 1 };
MergeSorter<int> mergeSorter = new MergeSorter<int>();
List<int> expectedArray = new List<int>() { 1, 2, 3, 4, 5 };
mergeSorter.Sort(arrayToSort);
CollectionAssert.AreEqual(expectedArray, arrayToSort);
}
public void AlreadySortedNumsTest()
{
List<int> arrayToSort = new List<int>() { 1, 2, 3, 4, 5 };
MergeSorter<int> mergeSorter = new MergeSorter<int>();
List<int> expectedArray = new List<int>() { 1, 2, 3, 4, 5 };
mergeSorter.Sort(arrayToSort);
CollectionAssert.AreEqual(expectedArray, arrayToSort);
}
public void PassingSortedItemCollection()
{
List<int> sortedNumbers = new List<int>() { 1, 1, 2, 2, 2, 3, 4, 5, 5, 7, 8, 9 };
MergeSorter<int> sorter = new MergeSorter<int>(sortedNumbers);
List<int> sortedList = new List<int>(sorter.Sort());
for (int i = 0; i < sortedNumbers.Count; i++)
{
Assert.AreEqual(sortedNumbers[i], sortedList[i]);
}
}
public void TestWithASingleItem()
{
List<int> collection = new List<int>();
collection.Add(3);
MergeSorter<int> sorter = new MergeSorter<int>();
sorter.Sort(collection);
Assert.AreEqual(1, collection.Count);
Assert.AreEqual(3, collection[0]);
}
public void merge_sort_one_element_input_same_output()
{
int[] input = { 4 };
var sorter = new MergeSorter <int>(input);
int[] actual = sorter.Sort();
int[] expected = { 4 };
actual.ShouldBeEquivalentTo(expected);
}
static void Main(string[] args)
{
double[] a = new double[100000];
for(int i=0; i<100000; i++)
{
a[i] = Math.Cos(i);
}
MergeSorter<double> ms = new MergeSorter<double>();
a = ms.Sort(a);
Console.WriteLine("Done!");
}
public void TestSortLengthOfCollection()
{
List<int> collection = new List<int>()
{
3, 5, 21, 543, 2, 12, 3, 65, 34, 234, 23, 12, 3, 43, 12, 32, 341, 24, 23
};
int count = collection.Count;
MergeSorter<int> sorter = new MergeSorter<int>();
sorter.Sort(collection);
Assert.AreEqual(count, collection.Count);
}
internal static void Main(string[] args)
{
var collection = new SortableCollection<int>(new[] { 22, -2, 300, 11, 55, 33, 10, -15, 88, 101, 33, 0, 101, 44, 33 });
Console.WriteLine("All items before sorting:");
collection.PrintAllItemsOnConsole();
Console.WriteLine();
Console.WriteLine("SelectionSorter result:");
collection.Sort(new SelectionSorter<int>());
collection.PrintAllItemsOnConsole();
Console.WriteLine();
collection = new SortableCollection<int>(new[] { 22, -2, 300, 11, 55, 33, 10, -15, 88, 101, 33, 0, 101, 44, 33 });
Console.WriteLine("Quicksorter result:");
var quickSorter = new Quicksorter<int>();
collection.Sort(quickSorter);
quickSorter.PrintResults();
//collection.PrintAllItemsOnConsole();
Console.WriteLine();
collection = new SortableCollection<int>(new[] { 22, -2, 300, 11, 55, 33, 10, -15, 88, 101, 33, 0, 101, 44, 33 });
Console.WriteLine("MergeSorter result:");
var mergeSort = new MergeSorter<int>();
collection.Sort(mergeSort);
mergeSort.ShowResults();
//collection.PrintAllItemsOnConsole();
Console.WriteLine();
Console.WriteLine("Linear search 101:");
Console.WriteLine(collection.LinearSearch(101));
Console.WriteLine();
Console.WriteLine("Binary search 101:");
Console.WriteLine(collection.BinarySearch(101));
Console.WriteLine();
collection = new SortableCollection<int>(new int[20]);
for (int i = 1; i <= 20; i++)
{
collection.Items[i - 1] = i;
}
Console.WriteLine("All items before sorting:");
collection.PrintAllItemsOnConsole();
Console.WriteLine("Shuffle:");
collection.Shuffle();
collection.PrintAllItemsOnConsole();
Console.WriteLine();
Console.WriteLine("Shuffle again:");
collection.Shuffle();
collection.PrintAllItemsOnConsole();
}
/// <summary>
/// エントリーポイント
/// </summary>
/// <param name="args"></param>
static void Main(string[] args)
{
// データ準備
int[] array = { 9, 7, 8, 5, 6, 3, 4, 1, 2, 0 };
DebugPrint(array.ToList());
Debug.WriteLine("--------");
// バブルソート生成
var sorter = new MergeSorter();
sorter.OnUpdate += (sender, e) => DebugPrint(array.ToList());
// ソート実行
sorter.Sort(array);
}
public void TestWithTwoItems()
{
List<int> collection = new List<int>();
collection.Add(3);
collection.Add(0);
MergeSorter<int> sorter = new MergeSorter<int>();
sorter.Sort(collection);
Assert.AreEqual(2, collection.Count);
Assert.AreEqual(0, collection[0]);
Assert.AreEqual(3, collection[1]);
}
public void TestSortIsSortedWithListSort()
{
List<int> collection = new List<int>()
{
3, 5, 21, 543, 2, 12, 3, 65, 34, 234, 23, 12, 3, 43, 12, 32, 341, 24, 23
};
MergeSorter<int> sorter = new MergeSorter<int>();
sorter.Sort(collection);
List<int> collection2 = new List<int>()
{
3, 5, 21, 543, 2, 12, 3, 65, 34, 234, 23, 12, 3, 43, 12, 32, 341, 24, 23
};
collection2.Sort();
CollectionAssert.AreEqual(collection2, collection);
}
public void TestWithOddNumberOfItems()
{
List<int> collection = new List<int>();
collection.Add(3);
collection.Add(0);
collection.Add(11);
collection.Add(-3);
collection.Add(5);
collection.Add(0);
collection.Add(4);
MergeSorter<int> sorter = new MergeSorter<int>();
sorter.Sort(collection);
Assert.AreEqual(7, collection.Count);
Assert.IsTrue(SortableCollection<int>.IsSorted(collection));
}
public void MergeSorterSortInt()
{
int[] s = new int[6];
s[0] = 3;
s[1] = 2;
s[2] = 4;
s[3] = 1;
s[4] = 0;
s[5] = 5;
MergeSorter<int> ms = new MergeSorter<int>();
int[] sorted_s = ms.Sort(s);
Assert.AreEqual(sorted_s[0], 0);
Assert.AreEqual(sorted_s[1], 1);
Assert.AreEqual(sorted_s[2], 2);
Assert.AreEqual(sorted_s[3], 3);
Assert.AreEqual(sorted_s[4], 4);
Assert.AreEqual(sorted_s[5], 5);
}
public void TestSortIsSortedWithCheck()
{
List<int> collection = new List<int>()
{
3, 5, 21, 543, 2, 12, 3, 65, 34, 234, 23, 12, 3, 43, 12, 32, 341, 24, 23
};
MergeSorter<int> sorter = new MergeSorter<int>();
sorter.Sort(collection);
bool isSorted = true;
for (int i = 0; i < collection.Count - 1; i++)
{
if (collection[i] > collection[i + 1])
{
isSorted = false;
}
}
Assert.IsTrue(isSorted);
}
static void Main(string[] args)
{
MergeSorter oSorter = new MergeSorter();
//--------------------------------------
//Create Array List, add some numbers
//--------------------------------------
ArrayList arrayUnsorted = new ArrayList();
arrayUnsorted.Add(1);
arrayUnsorted.Add(33);
arrayUnsorted.Add(4);
arrayUnsorted.Add(43);
//--------------------------------------
//Sort
//--------------------------------------
ArrayList arraySorted = oSorter.MergeSort(arrayUnsorted);
//--------------------------------------
//Print
//--------------------------------------
foreach (int i in arraySorted)
{
Console.WriteLine(i);
}
}
public void Given_two_empty_lists_should_get_an_empty_list()
{
var list1 = new int[] {};
var list2 = new int[] {};
var sorter = new MergeSorter<int>();
var result = sorter.Merge(list1, list2, (a, b) => a.CompareTo(b)).ToList();
result.ShouldBeEmpty();
}
