public void AddHaulDestination(IHaulDestination haulDestination) { if (allHaulDestinationsInOrder.Contains(haulDestination)) { Log.Error("Double-added haul destination " + haulDestination.ToStringSafe()); return; } allHaulDestinationsInOrder.Add(haulDestination); allHaulDestinationsInOrder.InsertionSort(CompareHaulDestinationPrioritiesDescending); ISlotGroupParent slotGroupParent = haulDestination as ISlotGroupParent; if (slotGroupParent == null) { return; } SlotGroup slotGroup = slotGroupParent.GetSlotGroup(); if (slotGroup == null) { Log.Error("ISlotGroupParent gave null slot group: " + slotGroupParent.ToStringSafe()); return; } allGroupsInOrder.Add(slotGroup); allGroupsInOrder.InsertionSort(CompareSlotGroupPrioritiesDescending); List <IntVec3> cellsList = slotGroup.CellsList; for (int i = 0; i < cellsList.Count; i++) { SetCellFor(cellsList[i], slotGroup); } map.listerHaulables.Notify_SlotGroupChanged(slotGroup); map.listerMergeables.Notify_SlotGroupChanged(slotGroup); }
public List <WorkGiver> GetWorkGivers(bool emergency) { if (emergency && workGiversEmergencyCache != null) { return(workGiversEmergencyCache); } if (!emergency && workGiversNonEmergencyCache != null) { return(workGiversNonEmergencyCache); } List <WorkTypeDef> wtsByPrio = new List <WorkTypeDef>(); List <WorkTypeDef> allDefsListForReading = DefDatabase <WorkTypeDef> .AllDefsListForReading; int num = 999; for (int i = 0; i < allDefsListForReading.Count; i++) { WorkTypeDef workTypeDef = allDefsListForReading[i]; int priority = GetPriority(workTypeDef); if (priority > 0) { if (priority < num) { if (workTypeDef.workGiversByPriority.Any((WorkGiverDef wg) => wg.emergency == emergency)) { num = priority; } } wtsByPrio.Add(workTypeDef); } } wtsByPrio.InsertionSort(delegate(WorkTypeDef a, WorkTypeDef b) { float value = (float)(a.naturalPriority + (4 - this.GetPriority(a)) * 100000); return(((float)(b.naturalPriority + (4 - this.GetPriority(b)) * 100000)).CompareTo(value)); }); List <WorkGiver> workGivers = new List <WorkGiver>(); for (int j = 0; j < wtsByPrio.Count; j++) { WorkTypeDef workTypeDef2 = wtsByPrio[j]; for (int k = 0; k < workTypeDef2.workGiversByPriority.Count; k++) { WorkGiver worker = workTypeDef2.workGiversByPriority[k].Worker; workGivers.Add(worker); } } // Fill cache if (emergency) { workGiversEmergencyCache = workGivers; } else { workGiversNonEmergencyCache = workGivers; } return(workGivers); }
public override void CallingSortOnAnEmptyListRemainsEmpty() { IList <int> empty = new List <int>(); empty.InsertionSort(); Assert.Empty(empty); }
private bool SortByZ() //returns true if the childNodes changed, false if they didn't { //using InsertionSort because it's stable (meaning equal values keep the same order) //this is unlike List.Sort, which is unstable, so things would constantly shift if equal. _childNodes.InsertionSort(ZComparison); //check if the order has changed, and if it has, update the quads/depth order //http://stackoverflow.com/questions/3030759/arrays-lists-and-computing-hashvalues-vb-c int hash = 269; unchecked //don't throw int overflow exceptions { foreach (FNode node in _childNodes) { hash = (hash * 17) + node.GetHashCode(); } } if (hash != _oldChildNodesHash) { _oldChildNodesHash = hash; return(true); //order has changed } return(false); //order hasn't changed }
public void InsertionSort_ListGetsSorted() { // Test sorting by the integer key var actual_int = new List <int>(randList_int).ConvertAll(x => new MyClass { myInt = x }); actual_int.InsertionSort(x => x.myInt); Assert.AreEqual(expected_int.Count, actual_int.Count); expected_int.Each((o, i) => Assert.AreEqual(o.myInt, actual_int[i].myInt)); //// Tessorting by theth DateTime key var actual_dt = new List <DateTime>(randList_dt).ConvertAll(x => new MyClass { myDt = x }); actual_dt.InsertionSort(x => x.myDt); Assert.AreEqual(expected_dt.Count, actual_dt.Count); expected_dt.Each((o, i) => Assert.AreEqual(o.myDt, actual_dt[i].myDt)); //// Tessorting by theth string key var actual_str = new List <string>(randList_str).ConvertAll(x => new MyClass { myStr = x }); actual_str.InsertionSort(x => x.myStr); Assert.AreEqual(expected_str.Count, actual_str.Count); expected_str.Each((o, i) => Assert.AreEqual(o.myStr, actual_str[i].myStr)); }
static void Main(string[] args) { List <int> unsList = new List <int> { 10, // 0 -1, // 1 8, // 2 15, // 3 23, // 4 -100, //5 -16 //6 }; unsList.InsertionSort(); //unsList.SelectionSort(); //unsList.BubbleSort(); List <char> charList = new List <char> { 'z', 'x', 'a', 'r', ' ', '/', '-' }; charList.InsertionSort(); }
private bool SortByZ() //returns true if the childNodes changed, false if they didn't { //using InsertionSort because it's stable (meaning equal values keep the same order) //this is unlike List.Sort, which is unstable, so things would constantly shift if equal. //note: it will only return true if the order changed return(_childNodes.InsertionSort(ZComparison)); }
public void Draw() { UpdateLists(); draw.InsertionSort(drawOrder); for (int i = 0; i < draw.Count; i++) { draw[i].Draw(); } }
public void Update(float elapsedTime) { UpdateLists(); update.InsertionSort(updateOrder); for (int i = 0; i < update.Count; i++) { update[i].Update(elapsedTime); } }
public void InsertionSortTest() { Stopwatch timer = Stopwatch.StartNew(); timer.Start(); TestSet.InsertionSort(); timer.Stop(); Console.WriteLine("SORT TIME " + timer.ElapsedMilliseconds); }
public void Test_InsertionSort() { var list = new List <int>() { 4, 5, 1, 9, 2, 1, 7, 9, 64, 3 }; list.InsertionSort(); Assert.True(list.IsSorted()); }
public static void Main(string[] args) { List <int> myl = new List <int> { 6, 5, 6, 3, 7, 2, 0 }; myl.InsertionSort(); myl.ShowAll(); }
public static bool CacheWorkGiversInOrder(Pawn_WorkSettings __instance) { //Pawn_WorkSettings.wtsByPrio.Clear(); List <WorkTypeDef> wtsByPrio = new List <WorkTypeDef>(); //ADD List <WorkTypeDef> defsListForReading = DefDatabase <WorkTypeDef> .AllDefsListForReading; int num1 = 999; for (int index = 0; index < defsListForReading.Count; ++index) { WorkTypeDef w = defsListForReading[index]; int priority = __instance.GetPriority(w); if (priority > 0) { if (priority < num1 && w.workGiversByPriority.Any(wg => !wg.emergency)) { num1 = priority; } wtsByPrio.Add(w); //FIND REPLACE } } //FIND REPLACE wtsByPrio.InsertionSort((a, b) => { float num2 = a.naturalPriority + (4 - __instance.GetPriority(a)) * 100000; return(((float)(b.naturalPriority + (4 - __instance.GetPriority(b)) * 100000)).CompareTo(num2)); }); WorkGiverListClear(workGiversInOrderEmerg(__instance)); for (int index1 = 0; index1 < wtsByPrio.Count; ++index1) //FIND REPLACE { WorkTypeDef workTypeDef = wtsByPrio[index1]; ////FIND REPLACE for (int index2 = 0; index2 < workTypeDef.workGiversByPriority.Count; ++index2) { WorkGiver worker = workTypeDef.workGiversByPriority[index2].Worker; if (worker.def.emergency && __instance.GetPriority(worker.def.workType) <= num1) { WorkGiverListAdd(workGiversInOrderEmerg(__instance), worker); } } } WorkGiverListClear(workGiversInOrderNormal(__instance)); for (int index1 = 0; index1 < wtsByPrio.Count; ++index1) //FIND REPLACE { WorkTypeDef workTypeDef = wtsByPrio[index1]; //FIND REPLACE for (int index2 = 0; index2 < workTypeDef.workGiversByPriority.Count; ++index2) { WorkGiver worker = workTypeDef.workGiversByPriority[index2].Worker; if (!worker.def.emergency || __instance.GetPriority(worker.def.workType) > num1) { WorkGiverListAdd(workGiversInOrderNormal(__instance), worker); } } } workGiversDirty(__instance) = false; return(false); }
public void InsertionSort() { var list = new List <int> { 3, 2, 6, 9, 3, 55, 123, 32 }; var expected = new List <int>(list); list.InsertionSort(); expected.Sort(); Assert.IsTrue(list.SequenceEqual(expected)); }
public void InsertionSortTest() { List <int> list = new List <int> { 4, 2, 3, 1, 6, 7, 8, 9 }; list.InsertionSort(); Assert.AreEqual(1, list[0]); Assert.AreEqual(9, list[list.Count - 1]); }
public static void InsertionSort(List <int> myList, StreamWriter fisier = null, StreamWriter fisierValori = null) { Stopwatch sw = Stopwatch.StartNew(); myList.InsertionSort(); sw.Stop(); fisier.WriteLine("Insertion Sort"); fisierValori.WriteLine(sw.Elapsed); }
public void InsertionSort_Should_Sort() { IList <int> numbers = new List <int> { 2, 4, 1, 3 }; numbers = numbers.InsertionSort(); Assert.That(numbers, Is.EqualTo(new List <int> { 1, 2, 3, 4 })); }
private void CacheWorkGiversInOrder() { wtsByPrio.Clear(); List <WorkTypeDef> allDefsListForReading = DefDatabase <WorkTypeDef> .AllDefsListForReading; int num = 999; for (int i = 0; i < allDefsListForReading.Count; i++) { WorkTypeDef workTypeDef = allDefsListForReading[i]; int priority = GetPriority(workTypeDef); if (priority > 0) { if (priority < num && workTypeDef.workGiversByPriority.Any((WorkGiverDef wg) => !wg.emergency)) { num = priority; } wtsByPrio.Add(workTypeDef); } } wtsByPrio.InsertionSort(delegate(WorkTypeDef a, WorkTypeDef b) { float value = (float)(a.naturalPriority + (4 - GetPriority(a)) * 100000); return(((float)(b.naturalPriority + (4 - GetPriority(b)) * 100000)).CompareTo(value)); }); workGiversInOrderEmerg.Clear(); for (int j = 0; j < wtsByPrio.Count; j++) { WorkTypeDef workTypeDef2 = wtsByPrio[j]; for (int k = 0; k < workTypeDef2.workGiversByPriority.Count; k++) { WorkGiver worker = workTypeDef2.workGiversByPriority[k].Worker; if (worker.def.emergency && GetPriority(worker.def.workType) <= num) { workGiversInOrderEmerg.Add(worker); } } } workGiversInOrderNormal.Clear(); for (int l = 0; l < wtsByPrio.Count; l++) { WorkTypeDef workTypeDef3 = wtsByPrio[l]; for (int m = 0; m < workTypeDef3.workGiversByPriority.Count; m++) { WorkGiver worker2 = workTypeDef3.workGiversByPriority[m].Worker; if (!worker2.def.emergency || GetPriority(worker2.def.workType) > num) { workGiversInOrderNormal.Add(worker2); } } } workGiversDirty = false; }
public void InsertionSort_ListComparer_SortedList() { foreach (var lst in Data.TestLists.Lists) { var expectedList = new List <int>(lst); expectedList.Sort(); var testList = new List <int>(lst); testList.InsertionSort(new Data.IntComparer()); Assert.Equal(expectedList, testList); } }
public void InsertionSort() { var actual = new List <int>(); actual.AddRange(new [] { 5, 3, 1, 4, 2 }); var expected = new List <int>(); expected.AddRange(new [] { 1, 2, 3, 4, 5 }); actual.InsertionSort(); Assert.Equal(expected, actual); }
public static void DoTest() { var list1 = new ArrayList <int> { 23, 42, 4, 16, 8, 15, 9, 55, 0, 34, 12, 2 }; var list2 = new List <long> { 23, 42, 4, 16, 8, 15, 9, 55, 0, 34, 12, 2 }; // sort both lists list1.InsertionSort(); list2.InsertionSort(); bool isListEqual = true; for (int i = 0; i < list1.Count; i++) { if (list1[i] != list2[i]) { isListEqual = false; break; } } Assert.True(isListEqual); }
public void SortPrimitives() { List <int> li = new List <int> { 1, 6, 2, 3, 8, 10, 9, 7, 4, 5 }; Assert.AreEqual(10, li.Count); li.InsertionSort(); for (int i = 0; i < li.Count; i++) { Assert.AreEqual(i + 1, li[i]); } }
/// <summary> /// 测试方法001 /// </summary> public static void TestInsertionSort001(List <Element> list, bool descending) { Console.WriteLine("Test: _InsertionSort.cs 001"); if (list == null) { Console.WriteLine("要排序的数列为null,无法排序。程序为求效率,没有进行数列为null的检验。"); //Console.ReadLine(); } List <Element> lstElement = list; List <Element> lstOriginalElement = new List <Element>(lstElement.AsEnumerable()); lstElement.InsertionSort(descending); Tools.testError(lstElement, lstOriginalElement, descending); Console.WriteLine(); }
public static void DoTest() { ArrayList <int> list = new ArrayList <int> (); list.Add(23); list.Add(42); list.Add(4); list.Add(16); list.Add(8); list.Add(15); list.Add(9); list.Add(55); list.Add(0); list.Add(34); list.Add(12); list.Add(2); Console.WriteLine("Before Sort:\r\n" + list.ToHumanReadable() + "\r\n"); list.InsertionSort(); Console.WriteLine("After Sort:\r\n" + list.ToHumanReadable() + "\r\n"); // ANOTHER LIST TO SORT List <long> list2 = new List <long> (); list2.Add(23); list2.Add(42); list2.Add(4); list2.Add(16); list2.Add(8); list2.Add(15); list2.Add(9); list2.Add(55); list2.Add(0); list2.Add(34); list2.Add(12); list2.Add(2); list2.InsertionSort(); }
public void InsertionSort_Should_Sort_Hard() { var random = new System.Random(); IList <int> randomNumbers = new List <int>();; const int LIMIT = 100; for (int i = 0; i < LIMIT; i++) { randomNumbers.Add(random.Next(0, 100)); } randomNumbers = randomNumbers.OrderByDescending(i => i).ToList(); var test = randomNumbers.InsertionSort(); Assert.That(test, Is.EqualTo(randomNumbers)); }
public static void DoTest () { ArrayList<int> list = new ArrayList<int> (); list.Add (23); list.Add (42); list.Add (4); list.Add (16); list.Add (8); list.Add (15); list.Add (9); list.Add (55); list.Add (0); list.Add (34); list.Add (12); list.Add (2); Console.WriteLine ("Before Sort:\r\n" + list.ToHumanReadable() + "\r\n"); list.InsertionSort (); Console.WriteLine ("After Sort:\r\n" + list.ToHumanReadable() + "\r\n"); // ANOTHER LIST TO SORT List<long> list2 = new List<long> (); list2.Add (23); list2.Add (42); list2.Add (4); list2.Add (16); list2.Add (8); list2.Add (15); list2.Add (9); list2.Add (55); list2.Add (0); list2.Add (34); list2.Add (12); list2.Add (2); list2.InsertionSort (); }
public void SortingARangeOfItemsInAscendingOrderAndCheckingIfSorted() { var list = new List <int>(); int minElement = -3000; int maxElement = 3000; int addedElements = 0; //Adding every seventh number, then every fifth number, //every third and at last all numbers //NOTE: some items are added more than once for (int i = 7; i > 0; i -= 2) { int el = minElement; while (el <= maxElement) { list.Add(el); addedElements++; el += i; } } int beginSortAt = addedElements / 3; int sortedCount = addedElements / 2; list.InsertionSort(beginSortAt, sortedCount, null); var last = int.MinValue; for (int i = beginSortAt; i < beginSortAt + sortedCount; i++) { if (last > list[i]) { Assert.Fail(); } last = list[i]; } }
public void SortingInAscendingOrderUsingAComparisonAndCheckingIfSorted() { var list = new List <int>(); int minElement = -3000; int maxElement = 3000; int addedElements = 0; //Adding every seventh number, then every fifth number, //every third and at last all numbers //NOTE: some items are added more than once for (int i = 7; i > 0; i -= 2) { int el = minElement; while (el <= maxElement) { list.Add(el); addedElements++; el += i; } } list.InsertionSort((x, y) => x.CompareTo(y)); var last = int.MinValue; foreach (var item in list) { if (last > item) { Assert.Fail(); } last = item; } }
public void Update(GameTime gameTime) { if (EnableInput && Visible #if WINDOWS ) #else && !Guide.IsVisible) #endif { foreach (var actor in actors) { actor.Evaluate(gameTime, this); } } buffer.Clear(); AddControlsToBuffer(Root); buffer.InsertionSort(ControlStrataComparer.BottomToTop); for (int i = 0; i < buffer.Count; i++) { buffer[i].Update(gameTime); } }
static void Main(string[] args) { while (true) { Console.Write("------------\nElements: "); int n = Convert.ToInt32(Console.ReadLine()); Console.WriteLine("------------"); var sortme = new List <int>(); var orderme = new List <Foo>(); DateTime startTime; Random randNum = new Random(); IReadOnlyList <int> li = Enumerable.Repeat(0, n).Select(i => randNum.Next(0, 500)).ToArray(); Console.WriteLine("\n** Sort items by value **\n"); sortme = new List <int>(li); startTime = DateTime.Now; sortme.BubbleSort(); Console.WriteLine("Bubble took: {0} ms", (DateTime.Now - startTime).TotalMilliseconds); sortme = new List <int>(li); startTime = DateTime.Now; sortme.InsertionSort(); Console.WriteLine("Insertion took: {0} ms", (DateTime.Now - startTime).TotalMilliseconds); sortme = new List <int>(li); startTime = DateTime.Now; sortme.SelectionSort(); Console.WriteLine("Selection took: {0} ms", (DateTime.Now - startTime).TotalMilliseconds); sortme = new List <int>(li); startTime = DateTime.Now; sortme.HeapSort(); Console.WriteLine("Heap took: {0} ms", (DateTime.Now - startTime).TotalMilliseconds); sortme = new List <int>(li); startTime = DateTime.Now; sortme.MergeSort(); Console.WriteLine("Merge took: {0} ms", (DateTime.Now - startTime).TotalMilliseconds); Console.WriteLine(); Console.WriteLine("\n** Sort items by key **\n"); IReadOnlyList <Foo> list = new List <int>(li).ConvertAll(x => new Foo { bar = x }); orderme = new List <Foo>(list); startTime = DateTime.Now; orderme.BubbleSort(x => x.bar); Console.WriteLine("Bubble took: {0} ms", (DateTime.Now - startTime).TotalMilliseconds); orderme = new List <Foo>(list); startTime = DateTime.Now; orderme.InsertionSort(x => x.bar); Console.WriteLine("Insertion took: {0} ms", (DateTime.Now - startTime).TotalMilliseconds); orderme = new List <Foo>(list); startTime = DateTime.Now; orderme.SelectionSort(x => x.bar); Console.WriteLine("Selection took: {0} ms", (DateTime.Now - startTime).TotalMilliseconds); orderme = new List <Foo>(list); startTime = DateTime.Now; orderme.HeapSort(x => x.bar); Console.WriteLine("Heap took: {0} ms", (DateTime.Now - startTime).TotalMilliseconds); orderme = new List <Foo>(list); startTime = DateTime.Now; orderme.MergeSort(x => x.bar); Console.WriteLine("Merge took: {0} ms", (DateTime.Now - startTime).TotalMilliseconds); Console.WriteLine(); } }
private void SortAreas() { areas.InsertionSort((Area a, Area b) => b.ListPriority.CompareTo(a.ListPriority)); }
static void Main(string[] args) { while (true) { Console.Write("------------\nElements: "); int n = Convert.ToInt32(Console.ReadLine()); Console.WriteLine("------------"); var sortme = new List<int>(); var orderme = new List<Foo>(); DateTime startTime; Random randNum = new Random(); IReadOnlyList<int> li = Enumerable.Repeat(0, n).Select(i => randNum.Next(0, 500)).ToArray(); Console.WriteLine("\n** Sort items by value **\n"); sortme = new List<int>(li); startTime = DateTime.Now; sortme.BubbleSort(); Console.WriteLine("Bubble took: {0} ms", (DateTime.Now - startTime).TotalMilliseconds); sortme = new List<int>(li); startTime = DateTime.Now; sortme.InsertionSort(); Console.WriteLine("Insertion took: {0} ms", (DateTime.Now - startTime).TotalMilliseconds); sortme = new List<int>(li); startTime = DateTime.Now; sortme.SelectionSort(); Console.WriteLine("Selection took: {0} ms", (DateTime.Now - startTime).TotalMilliseconds); sortme = new List<int>(li); startTime = DateTime.Now; sortme.HeapSort(); Console.WriteLine("Heap took: {0} ms", (DateTime.Now - startTime).TotalMilliseconds); sortme = new List<int>(li); startTime = DateTime.Now; sortme.MergeSort(); Console.WriteLine("Merge took: {0} ms", (DateTime.Now - startTime).TotalMilliseconds); Console.WriteLine(); Console.WriteLine("\n** Sort items by key **\n"); IReadOnlyList<Foo> list = new List<int>(li).ConvertAll(x => new Foo { bar = x }); orderme = new List<Foo>(list); startTime = DateTime.Now; orderme.BubbleSort(x => x.bar); Console.WriteLine("Bubble took: {0} ms", (DateTime.Now - startTime).TotalMilliseconds); orderme = new List<Foo>(list); startTime = DateTime.Now; orderme.InsertionSort(x => x.bar); Console.WriteLine("Insertion took: {0} ms", (DateTime.Now - startTime).TotalMilliseconds); orderme = new List<Foo>(list); startTime = DateTime.Now; orderme.SelectionSort(x => x.bar); Console.WriteLine("Selection took: {0} ms", (DateTime.Now - startTime).TotalMilliseconds); orderme = new List<Foo>(list); startTime = DateTime.Now; orderme.HeapSort(x => x.bar); Console.WriteLine("Heap took: {0} ms", (DateTime.Now - startTime).TotalMilliseconds); orderme = new List<Foo>(list); startTime = DateTime.Now; orderme.MergeSort(x => x.bar); Console.WriteLine("Merge took: {0} ms", (DateTime.Now - startTime).TotalMilliseconds); Console.WriteLine(); } }
static unsafe void Main(string[] args) { /*Consistency benkmark.*/ Console.WriteLine("Consistency benchmarking..."); List<int> consistencyList1 = new List<int>() { 13, 3, 1, 0, 11, 4, 12, 1 }; List<int> consistencyList2 = new List<int>(consistencyList1); List<int> consistencyList3 = new List<int>(consistencyList1); List<int> consistencyList4 = new List<int>(consistencyList1); List<int> consistencyList5 = new List<int>(consistencyList1); Console.WriteLine("Quick Sort:"); consistencyList1.QuickSort(); foreach(int val in consistencyList1) { if (consistencyList1.IndexOf(val) != consistencyList1.Count-1) { Console.Write(val + ","); } else { Console.WriteLine(val); } } Console.WriteLine(); Console.WriteLine("Insertion Sort:"); consistencyList2.InsertionSort(); foreach (int val in consistencyList2) { if (consistencyList2.IndexOf(val) != consistencyList2.Count - 1) { Console.Write(val + ","); } else { Console.WriteLine(val); } } Console.WriteLine(); Console.WriteLine("Bubble Sort:"); consistencyList3.BubbleSort(); foreach (int val in consistencyList3) { if (consistencyList3.IndexOf(val) != consistencyList3.Count - 1) { Console.Write(val + ","); } else { Console.WriteLine(val); } } Console.WriteLine(); Console.WriteLine("Merge Sort:"); consistencyList4.MergeSort(); foreach (int val in consistencyList4) { if (consistencyList4.IndexOf(val) != consistencyList4.Count - 1) { Console.Write(val + ","); } else { Console.WriteLine(val); } } Console.WriteLine(); Console.WriteLine("Heap Sort:"); consistencyList5.HeapSort(); foreach (int val in consistencyList5) { if (consistencyList5.IndexOf(val) != consistencyList5.Count - 1) { Console.Write(val + ","); } else { Console.WriteLine(val); } } Console.WriteLine(); /*Time Benchmark*/ int numVal = 15000; Console.WriteLine("Time benchmarking..." + numVal + " values"); List<int> myNewList = new List<int>(); Random randomizer = new Random(); for (int i = 0; i < numVal;i++) { myNewList.Add(randomizer.Next(0, 20000)); } List<int> myNewList1 = new List<int>(myNewList); List<int> myNewList2 = new List<int>(myNewList); List<int> myNewList3 = new List<int>(myNewList); List<int> myNewList4 = new List<int>(myNewList); List<int> myNewList5 = new List<int>(myNewList); //sort by default var watchDefault = System.Diagnostics.Stopwatch.StartNew(); myNewList.Sort(); watchDefault.Stop(); Console.WriteLine("Default CLR sort: " + watchDefault.ElapsedMilliseconds + " ms"); //sort by custom quick watchDefault.Restart(); myNewList1.QuickSort(); watchDefault.Stop(); Console.WriteLine("Custom Quick sort: " + watchDefault.ElapsedMilliseconds + " ms"); //sort by custom insertion watchDefault.Restart(); myNewList2.InsertionSort(); watchDefault.Stop(); Console.WriteLine("Custom Insertion sort: " + watchDefault.ElapsedMilliseconds + " ms"); //sort by custom bubble watchDefault.Restart(); myNewList3.BubbleSort(); watchDefault.Stop(); Console.WriteLine("Custom Bubble sort: " + watchDefault.ElapsedMilliseconds + " ms"); //sort by custom merge watchDefault.Restart(); myNewList4.MergeSort(); watchDefault.Stop(); Console.WriteLine("Custom Merge sort: " + watchDefault.ElapsedMilliseconds + " ms"); //sort by custom heap watchDefault.Restart(); myNewList5.HeapSort(); watchDefault.Stop(); Console.WriteLine("Custom Heap sort: " + watchDefault.ElapsedMilliseconds + " ms"); //done Console.WriteLine("Done!"); //default pause Console.ReadLine(); }