static void Main(string[] args)
{
int arraySize = 10000000;
RandomArray arr = new RandomArray(arraySize);
arr.FillArrayRandom();
if (arraySize < 10001)
{
Console.WriteLine("Size of the shuffled array :" + arraySize);
Console.WriteLine("Bubble Sort Took(miliseconds):" + BubbleSort.Sort(arr.Clone()));
Console.WriteLine("Selection Sort Took(miliseconds):" + SelectionSort.Sort(arr.Clone()));
Console.WriteLine("Insertion Sort Took(miliseconds):" + InsertionSort.Sort(arr.Clone()));
}
Console.WriteLine("Shell Sort Took(miliseconds):" + ShellSort.Sort(arr.Clone()));
Console.WriteLine("Merge Sort Took(miliseconds):" + MergeSort.Sort(arr.Clone()));
if (arraySize < 100000)
{
Console.WriteLine("Quick Sort Took(miliseconds):" + QuickSort.Sort(arr.Clone()));
}
Console.WriteLine("Counting Sort Took(miliseconds):" + CountingSort.Sort(arr.Clone()));
Console.WriteLine("Radix Sort Took(miliseconds):" + RadixSort.Sort(arr.Clone()));
}
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));
}
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);
}
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();
}