static void Main(string[] args)
{
int[] arrayOfInts = { 36, 35, 40, 39, 30, 5, 14, 13, 16, 17, 18, 20, 83, 84, 24, 28, 27, 26, 10, 90, 89, 78, 67, 48, 68, 97,
56, 45, 43, 31, 22, 94, 34, 43, 56, 37, 98, 58, 98, 87, 84, 81, 71, 51, 50, 42, 49, 47, 75, 91,
64, 63, 08, 84, 86, 88, 31, 51, 76, 87, 95, 92, 66, 55, 44, 33, 22, 11, 88, 99, 80, 60, 59, 82,
4, 6, 7, 2, 31, 51, 62, 21, 32, 25, 21, 29, 99, 94, 76, 54, 84, 03, 45, 69, 87, 22, 85, 53, 73,
11, 1, 23, 45, 12, 34, 67, 34, 89, 77, 16, 01, 38, 90, 56, 65, 33, 17, 19, 2, 9, 87, 88, 57, 74,
54, 93, 96, 52, 77, 6, 89, 32, 54, 89, 44, 46, 41, 76, 72, 70, 86, 84, 31, 07, 61, 67, 63 };
int[] bubbleSortInputArray = arrayOfInts.Clone() as int[];
Stopwatch watchBubbleSort = DoSortIntegers(BubbleSort.SortIntegers, bubbleSortInputArray);
Console.WriteLine("Sorted Array with Bubble Sort = {0} ", BuildOutputString(bubbleSortInputArray));
Console.WriteLine("Time taken for Bubble Sort = {0} ", watchBubbleSort.ElapsedTicks);
int[] selectionSortInputArray = arrayOfInts.Clone() as int[];
Stopwatch watchSelectionSort = DoSortIntegers(SelectionSort.SortIntegers, selectionSortInputArray);
Console.WriteLine("Sorted Array with Selection Sort = {0} ", BuildOutputString(selectionSortInputArray));
Console.WriteLine("Time taken for Selection Sort = {0} ", watchSelectionSort.ElapsedTicks);
int[] insertionSortInputArray = arrayOfInts.Clone() as int[];
Stopwatch watchInsertionSort = DoSortIntegers(InsertionSort.SortIntegers, insertionSortInputArray);
Console.WriteLine("Sorted Array with Insertion Sort = {0} ", BuildOutputString(insertionSortInputArray));
Console.WriteLine("Time taken for Insertion Sort = {0} ", watchInsertionSort.ElapsedTicks);
int[] quickSortInputArray = arrayOfInts.Clone() as int[];
Stopwatch watchQuickSort = DoSortIntegers(QuickSort.SortIntegers, quickSortInputArray);
Console.WriteLine("Sorted Array with Quick Sort = {0} ", BuildOutputString(quickSortInputArray));
Console.WriteLine("Time taken for Quick Sort = {0} ", watchQuickSort.ElapsedTicks);
//Disadvantage of Abstract factory. Since MergeSort.SortIntegers could not conform to the delegate signature
//Could not use that and therefore has to have this implementation.
int[] mergeSortInputArray = arrayOfInts.Clone() as int[];
Stopwatch watch = new Stopwatch();
watch.Start();
int[] mergeSortedArray = MergeSort.SortIntegers(mergeSortInputArray);
watch.Stop();
Console.WriteLine("Sorted Array with Merge Sort = {0} ", BuildOutputString(mergeSortedArray));
Console.WriteLine("Time taken for Merge Sort = {0} ", watch.ElapsedTicks);
Console.ReadKey();
}
static void Main(string[] args)
{
// -------------------- Bubble Sort --------------------
var bubbleNumbers = new[] { 7, 3, 1, 4, 6, 2, 3 };
var bubbleSorter = new BubbleSort();
bubbleSorter.Sort(bubbleNumbers);
Console.WriteLine($"[{string.Join(", ", bubbleNumbers)}]");
// -------------------- Selection Sort --------------------
var selectionNumbers = new[] { 7, 3, 1, 4, 6, 2, 3 };
var selectionSorter = new SelectionSort();
selectionSorter.Sort(selectionNumbers);
Console.WriteLine("[{0}]", string.Join(", ", selectionNumbers));
// -------------------- Insertion Sort --------------------
var insertionNumbers = new[] { 7, 3, 1, 4, 6, 2, 3 };
var insertionSorter = new InsertionSort();
insertionSorter.Sort(insertionNumbers);
Console.WriteLine("[{0}]", string.Join(", ", insertionNumbers));
// -------------------- Merge Sort --------------------
int[] mergeNumbers = { 7, 3, 1, 4, 6, 2, 3 };
var mergeSorter = new MergeSort();
mergeSorter.Sort(mergeNumbers);
Console.WriteLine("[{0}]", string.Join(", ", mergeNumbers));
// -------------------- Quick Sort --------------------
int[] quickNumbers = { 7, 3, 1, 4, 6, 2, 3 };
var quickSorter = new QuickSort();
quickSorter.Sort(quickNumbers);
Console.WriteLine("[{0}]", string.Join(", ", quickNumbers));
// -------------------- Counting Sort --------------------
int[] countingNumbers = { 7, 3, 1, 4, 6, 2, 3 };
var countingSorter = new CountingSort();
countingSorter.Sort(countingNumbers);
Console.WriteLine("[{0}]", string.Join(", ", countingNumbers));
// -------------------- Bucket Sort --------------------
int[] bucketNumbers = { 7, 3, 1, 4, 6, 2, 3 };
var bucketSorter = new BucketSort();
bucketSorter.Sort(bucketNumbers, 3);
Console.WriteLine("[{0}]", string.Join(", ", bucketNumbers));
}
static void Main(string[] args)
{
var array = new int[] { 6, 2, 9, 4, 5 };
var bubbleSort = new BubbleSort();
var selectionSort = new SelectionSort();
var insertionSort = new InsertionSort();
var mergeSort = new MergeSort();
Console.WriteLine("NoSorted: " + string.Join(",", array));
//bubbleSort.Sort(array);
//selectionSort.Sort(array);
//insertionSort.Sort(array);
mergeSort.Sort(array);
Console.WriteLine("Sorted: " + string.Join(",", array));
}
public void TryMergeSort()
{
MergeSort Merging = new MergeSort();
for (int i = 0; i < notSorted.Length; i++)
{
int value = random.Next(1, 5000);
notSorted[i] = value;
}
Merging.RecursiveMergeSort(notSorted, 0, notSorted.Length - 1);
Console.WriteLine("==========Integer Array OutPut===============");
for (int i = 0; i < notSorted.Length; i++)
{
Console.WriteLine(notSorted[i]);
}
Console.ReadKey();
}
static void Main(string[] args)
{
var rnd = new Random();
var arrSize = rnd.Next(1, 1000);
int[] arr = Enumerable.Repeat(0, arrSize).Select(x => rnd.Next(int.MinValue, int.MaxValue)).ToArray();
var bs = (int[])arr.Clone();
BubbleSort.Sort(bs);
Assert.IsTrue(IsSorted(bs));
var ss = (int[])arr.Clone();
SelectionSort.Sort(ss);
Assert.IsTrue(IsSorted(ss));
var @is = (int[])arr.Clone();
InsertionSort.Sort(@is);
Assert.IsTrue(IsSorted(@is));
var ms = (int[])arr.Clone();
MergeSort.Sort(ms);
Assert.IsTrue(IsSorted(ms));
var qs = (int[])arr.Clone();
QuickSort.Sort(qs);
Assert.IsTrue(IsSorted(qs));
var cs = (int[])arr.Clone();
CountingSort.Sort(cs);
Assert.IsTrue(IsSorted(cs));
var rs = (int[])arr.Clone();
RadixSort.Sort(rs);
Assert.IsTrue(IsSorted(rs));
var hs = (int[])arr.Clone();
HeapSort.Sort(hs);
Assert.IsTrue(IsSorted(hs));
}
static void RunSorts()
{
var watch = new System.Diagnostics.Stopwatch();
Console.WriteLine("Unsorted int array size of {0}", unsortedArray.Length);
watch.Start();
InsertionSort ISort = new InsertionSort(unsortedArray);
watch.Stop();
Console.WriteLine("Insertion Sort - Ticks/ Time in Milliseconds spent to create object and sort the array: " + watch.Elapsed.Ticks);
watch.Reset();
watch.Start();
MergeSort MSort = new MergeSort(unsortedArray);
watch.Stop();
Console.WriteLine("Merge Sort - Ticks/ Time in Milliseconds spent to create object and sort the array: " + watch.Elapsed.Ticks);
watch.Reset();
watch.Start();
QuickSort QSort = new QuickSort(unsortedArray);
watch.Stop();
Console.WriteLine("Quick Sort - Ticks/ Time in Milliseconds spent to create object and sort the array: " + watch.Elapsed.Ticks);
watch.Reset();
watch.Start();
Array.Sort(unsortedArray);
watch.Stop();
//This method uses the Array.Sort method, which applies the introspective sort as follows:
//•If the partition size is fewer than 16 elements, it uses an insertion sort algorithm.
//•If the number of partitions exceeds 2 * LogN, where N is the range of the input array, it uses a Heapsort algorithm.
//•Otherwise, it uses a Quicksort algorithm.
Console.WriteLine(".Net Sort - Ticks/ Time in Milliseconds spent to create object and sort the array: " + watch.Elapsed.Ticks);
}
static void Main(string[] args)
{
RegisterDependencies();
int[] unsortedNumbers;
using (var scope = Container.BeginLifetimeScope())
{
_timerService = scope.Resolve <ITimerService>();
unsortedNumbers = new int[] { 7, 2, 1, 6, 8, 5, 3, 4 };
var heapSort = new HeapSort(_timerService);
Sort(heapSort, unsortedNumbers);
unsortedNumbers = new int[] { 7, 2, 1, 6, 8, 5, 3, 4 };
var mergeSort = new MergeSort(_timerService);
Sort(mergeSort, unsortedNumbers);
unsortedNumbers = new int[] { 7, 2, 1, 6, 8, 5, 3, 4 };
var quickSort = new QuickSort(_timerService);
Sort(quickSort, unsortedNumbers);
}
}
static void Main(string[] args)
{
int[] array = new int[] { 5, 10, 3, 2, 4, 3 };
Console.Write("Bubble Sort: ");
BubbleSort.sort(array);
print(array);
array = new int[] { 5, 10, 3, 2, 4, 3 };
Console.Write("Insertion Sort: ");
InsertionSort.sort(array);
print(array);
array = new int[] { 5, 10, 3, 2, 4, 3 };
Console.Write("Selection Sort: ");
SelectionSort.sort(array);
print(array);
array = new int[] { 5, 10, 3, 2, 4, 3 };
Console.Write("Merge Sort: ");
MergeSort.sort(array, 0, array.Length - 1);
print(array);
}
public static void Sort(uint[] UnsortedArray, int Length, SortNames AlgorithmName)
{
ISort Algorithm = null;
switch (AlgorithmName)
{
case (SortNames.SelectionSort):
Algorithm = new SelectionSort();
break;
case (SortNames.InsertionSort):
Algorithm = new InsertionSort();
break;
case (SortNames.ShellSort1):
Algorithm = new ShellSort1();
break;
case (SortNames.ShellSort2):
Algorithm = new ShellSort2();
break;
case (SortNames.QuickSort):
Algorithm = new QuickSort();
break;
case (SortNames.MergeSort):
Algorithm = new MergeSort();
break;
case (SortNames.RadixSort):
Algorithm = new RadixSort();
break;
}
Algorithm.Sort(UnsortedArray, Length);
}
private void MergeSortButton_Click(object sender, EventArgs e)
{
var merge = new MergeSort <SortedItem>(items);
Button_Click(merge);
}
static void Main(string[] args)
{
Random random = new Random();
Console.WriteLine("Enter the Number");
int c = Console.Read();
int[] arr = new int[c];
for (int i = 0; i < c; i++)
{
arr[i] = random.Next();
}
Console.WriteLine("Choose The Algorhitm ");
Console.WriteLine("1: InsertSort");
Console.WriteLine("2: BubbleSort");
Console.WriteLine("3: Quick Sort");
Console.WriteLine("4: Heap Sort");
Console.WriteLine("5: Merge Sort");
Console.WriteLine("6: All");
string s = Console.ReadLine();
if (s.Length > 1)
{
for (int i = Convert.ToInt32(s.Substring(0, 1)); i <= Convert.ToInt32(s.Substring(2, 3)); i++)
{
switch (Convert.ToString(i))
{
case "1":
InsertSort.Sort(arr);
break;
case "2":
BubbleSort.Sort(arr);
break;
case "3":
QuickSort.Sort(arr, 0, arr.Length - 1);
break;
case "4":
HeapSort.Sort(ref arr);
break;
case "5":
MergeSort.Sort(ref arr, 0, arr.Length - 1);
break;
}
}
}
else
{
switch (s)
{
case "1":
InsertSort.Sort(arr);
break;
case "2":
BubbleSort.Sort(arr);
break;
case "3":
QuickSort.Sort(arr, 0, arr.Length - 1);
break;
case "4":
HeapSort.Sort(ref arr);
break;
case "5":
MergeSort.Sort(ref arr, 0, arr.Length - 1);
break;
case "6":
InsertSort.Sort(arr);
BubbleSort.Sort(arr);
QuickSort.Sort(arr, 0, arr.Length - 1);
HeapSort.Sort(ref arr);
MergeSort.Sort(ref arr, 0, arr.Length - 1);
break;
}
}
Console.ReadLine();
}
static void Main(string[] args)
{
int size = 20000;
int range = 10000;
BubbleSort bubbleSort = new BubbleSort();
int[] unsortedArray1 = Utils.generateArray(size, range);
var watch = System.Diagnostics.Stopwatch.StartNew();
bubbleSort.bubbleSort(unsortedArray1);
watch.Stop();
var elapsedMs = watch.Elapsed.TotalMilliseconds;
Console.WriteLine("bubble took time: " + elapsedMs);
CountSort countSort = new CountSort();
int[] unsortedArray2 = Utils.generateArray(size, range);
watch = System.Diagnostics.Stopwatch.StartNew();
countSort.countSort(unsortedArray2);
watch.Stop();
elapsedMs = watch.Elapsed.TotalMilliseconds;
Console.WriteLine("count took time: " + elapsedMs);
MergeSort mergeSort = new MergeSort();
int[] unsortedArray3 = Utils.generateArray(size, range);
watch = System.Diagnostics.Stopwatch.StartNew();
MergeSort.sort(unsortedArray3, 0, unsortedArray3.Length - 1);
watch.Stop();
elapsedMs = watch.Elapsed.TotalMilliseconds;
Console.WriteLine("merge took time: " + elapsedMs);
InsertionSort insertionSort = new InsertionSort();
int[] unsortedArray4 = Utils.generateArray(size, range);
watch = System.Diagnostics.Stopwatch.StartNew();
insertionSort.insertionSort(unsortedArray4);
watch.Stop();
elapsedMs = watch.Elapsed.TotalMilliseconds;
Console.WriteLine("insertion took time: " + elapsedMs);
QuickSort quickSort = new QuickSort();
int[] unsortedArray5 = Utils.generateArray(size, range);
watch = System.Diagnostics.Stopwatch.StartNew();
quickSort.quickSort(unsortedArray5);
watch.Stop();
elapsedMs = watch.Elapsed.TotalMilliseconds;
Console.WriteLine("quick took time: " + elapsedMs);
HeapSort heapSort = new HeapSort();
int[] unsortedArray6 = Utils.generateArray(size, range);
watch = System.Diagnostics.Stopwatch.StartNew();
heapSort.heapSort(unsortedArray6);
watch.Stop();
elapsedMs = watch.Elapsed.TotalMilliseconds;
Console.WriteLine("heap took time: " + elapsedMs);
SelectionSort selectionSort = new SelectionSort();
int[] unsortedArray7 = Utils.generateArray(size, range);
watch = System.Diagnostics.Stopwatch.StartNew();
selectionSort.selectionSort(unsortedArray7);
watch.Stop();
elapsedMs = watch.Elapsed.TotalMilliseconds;
Console.WriteLine("selection took time: " + elapsedMs);
Console.ReadKey();
}
/// <summary>
/// Sort the specified array.
/// </summary>
/// <returns>The sort.</returns>
/// <param name="a">The array.</param>
public static void sort(int[] a)
{
MergeSort.sortik(a, 0, a.Length - 1);;
}
static void Main(string[] args)
{
#region Selection Sort
//The selection sort algorithm sorts an array by repeatedly finding the minimum element(considering ascending order)
//from unsorted part and putting it at the beginning.The algorithm maintains two subarrays in a given array.
//1) The subarray which is already sorted.
//2) Remaining subarray which is unsorted.
//In every iteration of selection sort, the minimum element(considering ascending order) from the unsorted
//subarray is picked and moved to the sorted subarray.
//Time Complexity: O(N^2) as there are two nested loops.
//Auxiliary Space: O(1)
//The good thing about selection sort is it never makes more than O(N) swaps and can be useful when memory write is a costly operation.
//int[] arr = { 64, 25, 12, 22, 11 };
//SelectionSort.Sort(arr);
//Console.WriteLine("Sorted array");
//SelectionSort.PrintArray(arr);
#endregion
#region Bubble Sort
//Bubble Sort is the simplest sorting algorithm that works by repeatedly swapping the adjacent elements if they are in wrong order.
//Time Complexity: O(N^2)
//Auxiliary Space: O(1)
//var watch1 = System.Diagnostics.Stopwatch.StartNew();
//int[] arr = { 64, 25, 12, 22, 11, 50, 101, 34, 73, 44, 0, 12, 2222 };
//BubbleSort.Sort(arr);
//Console.WriteLine("Sorted array");
//BubbleSort.PrintArray(arr);
//watch1.Stop();
//var elapsedMs1 = watch1.ElapsedMilliseconds;
#endregion
#region Advanced Bubble Sort
// The same as Bubble Sort but when a pass goes through without swapping any elements, it stops as they are all sorted.
//Time Complexity: O(N^2)
//Auxiliary Space: O(1)
//var watch2 = System.Diagnostics.Stopwatch.StartNew();
//int[] arr2 = { 64, 25, 12, 22, 11, 50, 101, 34, 73, 44, 0, 12, 2222 };
//AdvancedBubbleSort.Sort(arr2);
//Console.WriteLine("Sorted array");
//AdvancedBubbleSort.PrintArray(arr2);
//watch2.Stop();
//var elapsedMs2 = watch2.ElapsedMilliseconds;
//Console.WriteLine($"BubbleSort 1: {elapsedMs1}"); // needs Bubble Sort uncommented
//Console.WriteLine($"BubbleSort 2: {elapsedMs2}");
#endregion
#region Insertion Sort
//Insertion sort is a simple sorting algorithm that works similar to the way you sort playing cards in your hands.
//The array is virtually split into a sorted and an unsorted part.Values from the unsorted part are picked and placed
//at the correct position in the sorted part.
//Algorithm
//To sort an array of size n in ascending order:
//1: Iterate from arr[1] to arr[n] over the array.
//2: Compare the current element(key) to its predecessor.
//3: If the key element is smaller than its predecessor, compare it to the elements before.Move the greater elements
//one position up to make space for the swapped element.
//Time Complexity: O(2N)
//Auxiliary Space: O(1)
//var watch2 = System.Diagnostics.Stopwatch.StartNew();
//int[] arr2 = { 64, 25, 12, 22, 11, 50, 101, 34, 73, 44, 0, 12, 2222 };
//InsertionSort.Sort(arr2);
//Console.WriteLine("Sorted array");
//InsertionSort.PrintArray(arr2);
//watch2.Stop();
//var elapsedMs2 = watch2.ElapsedMilliseconds;
//Console.WriteLine($"InsertionSort: {elapsedMs2}");
#endregion
#region Quick Sort
//Like Merge Sort, QuickSort is a Divide and Conquer algorithm. It picks an element as pivot and partitions the
//given array around the picked pivot.There are many different versions of quickSort that pick pivot in different ways.
//Always pick first element as pivot.
//Always pick last element as pivot (implemented below)
//Pick a random element as pivot.
//Pick median as pivot.
//The key process in quickSort is partition(). Target of partitions is, given an array and an element x of array as pivot,
//put x at its correct position in sorted array and put all smaller elements(smaller than x) before x, and put all greater
//elements(greater than x) after x. All this should be done in linear time.
//Time Complexity O(N^2)
//Space Complexity O(1)
//var watch2 = System.Diagnostics.Stopwatch.StartNew();
//int[] arr2 = { 64, 25, 12, 22, 11, 50, 101, 34, 73, 44, 0, 12, 2222 };
//QuickSort.Sort(arr2, 0, arr2.Length-1);
//Console.WriteLine("Sorted array");
//QuickSort.PrintArray(arr2);
//watch2.Stop();
//var elapsedMs2 = watch2.ElapsedMilliseconds;
//Console.WriteLine($"QuickSort: {elapsedMs2}");
#endregion
#region Merge Sort
//Like QuickSort, Merge Sort is a Divide and Conquer algorithm. It divides input array in two halves, calls itself for
//the two halves and then merges the two sorted halves.The merge() function is used for merging two halves.The
//merge(arr, l, m, r) is key process that assumes that arr[l..m] and arr[m + 1..r] are sorted and merges the two sorted
//sub - arrays into one.
//The following diagram from wikipedia shows the complete merge sort process for an example array { 38, 27, 43, 3, 9, 82, 10}.
//If we take a closer look at the diagram, we can see that the array is recursively divided in two halves till the size becomes 1.
//Once the size becomes 1, the merge processes comes into action and starts merging arrays back till the complete array is merged.
//Time Complexity O(N * Log N)
//Space Complexity O(N)
//var watch2 = System.Diagnostics.Stopwatch.StartNew();
//int[] arr2 = { 64, 25, 12, 22, 11, 50, 101, 34, 73, 44, 0, 12, 2222 };
//MergeSort.Sort(arr2, 0, arr2.Length - 1);
//Console.WriteLine("Sorted array");
//MergeSort.PrintArray(arr2);
//watch2.Stop();
//var elapsedMs2 = watch2.ElapsedMilliseconds;
//Console.WriteLine($"MergeSort: {elapsedMs2}");
#endregion
#region Tim Sort
//TimSort is a sorting algorithm based on Insertion Sort and Merge Sort.
//A stable sorting algorithm works in O(n Log n) time
//Used in Java’s Arrays.sort() as well as Python’s sorted() and sort().
//First sort small pieces using Insertion Sort, then merges the pieces using merge of merge sort.
//We divide the Array into blocks known as Run.We sort those runs using insertion sort one by one and then merge those runs using
//combine function used in merge sort. If the size of Array is less than run, then Array get sorted just by using Insertion Sort.
//The size of run may vary from 32 to 64 depending upon the size of the array.Note that merge function performs well when sizes
//subarrays are powers of 2.The idea is based on the fact that insertion sort performs well for small arrays.
var watch2 = System.Diagnostics.Stopwatch.StartNew();
int[] arr2 = { 64, 25, 12, 22, 11, 50, 101, 34, 73, 44, 0, 12, 2222 };
TimSort.Sort(arr2, arr2.Length);
Console.WriteLine("Sorted array");
MergeSort.PrintArray(arr2);
watch2.Stop();
var elapsedMs2 = watch2.ElapsedMilliseconds;
Console.WriteLine($"TimSort: {elapsedMs2}");
#endregion
}
static void Main(string[] args)
{
int arraySize = 10;
int arrayUpperLimits = 100;
int repeatTimes = 1;
bool enableLogging = true;
int[] inputArray;
double[] executionTime = new double[repeatTimes];
Stopwatch stopwatch = new Stopwatch();
//Slow - O(n^2)
InsertionSort mInsertionSort = new InsertionSort();
SelectionSort mSelectionSort = new SelectionSort();
BubbleSort mBubbleSort = new BubbleSort();
//Fast - O(n*lgn)
MergeSort mMergeSort = new MergeSort();
HeapSort mHeapSort = new HeapSort();
QuickSort mQuickSort = new QuickSort();
//Linear - O(n)
CountingSort mCountingSort = new CountingSort();
RadixSort mRadixSort = new RadixSort();
BucketSort mBucketSort = new BucketSort();
//Test the execution time repeatly.
for (int i = 0; i < repeatTimes; i++)
{
//Always create new Array object, even though the contents are the same.
//Because each array will be modified at the end of each loop.
inputArray = ArrayHandler.Create(arraySize, enableLogging, arrayUpperLimits);
//inputArray = ArrayHandler.CreateAlmostSorted(arraySize, enableLogging);
//inputArray = new int[] { 122, 44, 122, 55, 33, 55, 44, 23};
stopwatch.Start();
//----------------------------------------------------------------------------------------//
// A L G O R I T H M T E S T E D H E R E //
//----------------------------------------------------------------------------------------//
//------- 0.Sort in VC# -------
//Array.Sort(inputArray); //7ms 10^5
//##################################### O(n*n) #############################################
//------- 1.Insertion Sort ~ O(n^2) -------
mInsertionSort.Sort(inputArray); //95ms 10^4
//mInsertionSort.SortWithTrace(inputArray);
//mInsertionSort.Sort_Recursive(inputArray);
//------- 2.Selection Sort ~ O(n^2) -------
//mSelectionSort.Sort(inputArray); //164ms 10^4
//mSelectionSort.SortWithTrace(inputArray);
//------- 3.Bubble Sort ~ O(n^2) -------
//mBubbleSort.Sort(inputArray); //600ms 10^4
//mBubbleSort.OriginalBubbleSort(inputArray); //550ms 10^4
//################################### O(n*lgn) #############################################
//------- 4.Merge Sort ~ O(n*lgn) -------
//mMergeSort.Sort(inputArray); //27ms 10^5
//mMergeSort.Sort_Enhanced(inputArray); //25ms 10^5
//------- 5.Heap Sort ~ O(n*lgn) -------
//mHeapSort.Sort(inputArray); //53ms 10^5
//------- 6.Quick Sort ~ O(n*lgn) -------
//mQuickSort.Sort(inputArray); //40ms 10^5
//mQuickSort.Sort_Hoare(inputArray, enableLogging); //23ms 10^5
//mQuickSort.Sort_Lomuto(inputArray, enableLogging);
//###################################### O(n) ##############################################
//------- 7.Counting Sort ~ O(n) -------
//inputArray = mCountingSort.Sort(inputArray); //2ms 10^5
//------- 8.Radix Sort ~ O(n) -------
//inputArray = mRadixSort.Sort(inputArray, enableLogging); //114ms 10^5
//------- 9.Bucket Sort ~ O(n) -------
//inputArray = mBucketSort.Sort(inputArray); //13ms 10^5
//------------------------------------------------------------------------------------------
// A L G O R I T H M T E S T E N D E D
//------------------------------------------------------------------------------------------
stopwatch.Stop();
executionTime[i] = stopwatch.ElapsedMilliseconds;
Console.Write(executionTime[i] + " ");
Console.WriteLine("");
stopwatch.Reset();
ArrayHandler.Print(inputArray, enableLogging);
}
//Print Execution Time
double ts = executionTime.Average();
Console.WriteLine("Average Execution Time in milliseconds: " + ts);
Console.ReadLine();
}
/// <summary>
/// Sort the specified array with the algorithm of index i.
/// </summary>
/// <returns>The sort.</returns>
/// <param name="a">The array of integers.</param>
/// <param name="i">The index of the algorithm.</param>
static void sort(int[] a, int i)
{
switch (i)
{
// Bubble Sort.
case 1:
// Stores the memory allocated at the moment.
var mem1 = GC.GetTotalMemory(false);
// Starts a new stopwatch.
var watch = System.Diagnostics.Stopwatch.StartNew();
// Calls the Bubble Sort algorithm.
BubbleSort.sort(a);
// Stops the stopwatch.
watch.Stop();
// Gets the memory allocated at the moment and sumtracts the
// older one to get the memory used in the intermediate process.
var mem2 = GC.GetTotalMemory(false) - mem1;
// Writes the memory usage in the index of its algorithm in the memory array.
MainClass.mem[i] = mem2;
// Gets the value of the stopwatch and stores itin the running time array.
double time = watch.ElapsedTicks;
MainClass.eff[i] = time;
break;
// Similarly the other cases.
case 2:
mem1 = GC.GetTotalMemory(false);
watch = System.Diagnostics.Stopwatch.StartNew();
InsertSort.sort(a);
watch.Stop();
mem2 = GC.GetTotalMemory(false) - mem1;
MainClass.mem[i] = mem2;
time = watch.ElapsedTicks;
MainClass.eff[i] = time;
break;
case 3:
mem1 = GC.GetTotalMemory(false);
watch = System.Diagnostics.Stopwatch.StartNew();
QuickSort.sort(a);
watch.Stop();
mem2 = GC.GetTotalMemory(false) - mem1;
MainClass.mem[i] = mem2;
time = watch.ElapsedTicks;
MainClass.eff[i] = time;
break;
case 4:
mem1 = GC.GetTotalMemory(false);
watch = System.Diagnostics.Stopwatch.StartNew();
HeapSort.sort(a);
watch.Stop();
mem2 = GC.GetTotalMemory(false) - mem1;
MainClass.mem[i] = mem2;
time = watch.ElapsedTicks;
MainClass.eff[i] = time;
break;
case 5:
mem1 = GC.GetTotalMemory(false);
watch = System.Diagnostics.Stopwatch.StartNew();
MergeSort.sort(a);
watch.Stop();
mem2 = GC.GetTotalMemory(false) - mem1;
MainClass.mem[i] = mem2;
time = watch.ElapsedTicks;
MainClass.eff[i] = time;
break;
}
}
private static void Execute()
{
var random = RandomArray();
Console.WriteLine("Today's Randomly selected integers are:");
foreach (var r in random)
{
Console.WriteLine(r);
}
Seperator();
var selectionSort = new SelectionSort().Sort(random);
Console.WriteLine("Utilising Selection Sort:");
foreach (var selection in selectionSort)
{
Console.WriteLine(selection);
}
Seperator();
var insertionSort = new InsertionSort().Sort(random);
Console.WriteLine("Utilising Insertion Sort:");
foreach (var insertion in insertionSort)
{
Console.WriteLine(insertion);
}
Seperator();
var mergeSort = new MergeSort().Sort(random, 0, random.Length - 1);
Console.WriteLine("Utilising Merge Sort:");
var fullMergeWatch = Stopwatch.StartNew();
foreach (var merge in mergeSort)
{
Console.WriteLine(merge);
}
fullMergeWatch.Stop();
var elapsedTime = fullMergeWatch.Elapsed;
Seperator();
Console.WriteLine($"A Full cycle of a merge sort takes {elapsedTime} milliseconds");
Console.WriteLine("One iteration of Selection Sort takes");
var s = new Stopwatch();
Console.WriteLine(s.Time(() => new SelectionSort().Sort(random), 1));
Console.WriteLine("One iteration of Insertion Sort takes");
var i = new Stopwatch();
Console.WriteLine(i.Time(() => new InsertionSort().Sort(random), 1));
Console.WriteLine("One iteration of Merge Sort takes");
var m = new Stopwatch();
Console.WriteLine(m.Time(() => new MergeSort().Sort(random, 0, random.Length - 1), 1));
Seperator();
TimeTheMethods(random);
}