public void Test() { ShellSort <Int32> sort = new ShellSort <Int32>(); Int32[] array = SortData.CreateUnsortedArray(); sort.Sort(array); Assert.True(SortData.VerifyArrayIsSorted(array)); }
public void TestCaseDescending() { SampleArray <int> .Get(out int[] arr, out int[] arrCopy, () => _random.Next(0, 100)); Array.Sort(arrCopy, new Comparison <int>((x, y) => y.CompareTo(x))); var sort = new ShellSort <int>(Comparer <int> .Create(new Comparison <int>((x, y) => y.CompareTo(x)))); sort.Sort(arr); Assert.Equal(arr, arrCopy); }
static void Main(string[] args) { DemailChanges(); return; MathsPrograms(); return; //int[] unSortedArray = new[] {3, 5, 1, 4, 7, 2, 8, 9, 10,3}; int[] unSortedArray = new[] { 23, 29, 15, 19, 31, 7, 9, 5, 2 }; Console.WriteLine("unsorted Array"); unSortedArray.ToList().ForEach(x => Console.Write(x.ToString() + " ")); Console.WriteLine("\n Press number for following: \n"); Console.WriteLine("Press 1 for Selection Sort \n"); Console.WriteLine("Press 2 for Bubble Sort \n"); Console.WriteLine("Press 3 for Merge Sort \n"); Console.WriteLine("Press 4 for Quick Sort \n"); Console.WriteLine("Press 5 for Insertion Sort\n"); Console.WriteLine("Press 6 for Bucket Sort\n"); Console.WriteLine("Press 7 for Shell Sort\n"); string number = Console.ReadLine(); int result; ISorting sort = new SelectionSort(); if (!int.TryParse(number, out result) && (result > 0 && result <= 6)) { Console.WriteLine("Provide the input from 1 to 6"); } switch (number) { case "1": sort = new SelectionSort(); sort.Sort(unSortedArray); break; case "2": sort = new BubbleSort(); sort.Sort(unSortedArray); break; case "5": sort = new InsertionSort(); sort.Sort(unSortedArray); break; case "7": sort = new ShellSort(); sort.Sort(unSortedArray); break; } unSortedArray.ToList().ForEach(x => Console.Write(x.ToString() + " ")); Console.ReadKey(); }
private static void SortAllTabsFromList(List <int[]> list, int mode) { Time[] timeArray = new Time[list.Count]; //Tworzenie tablicy obiektów Time (Każdy pojedynczy obiekt klasy Time przechowuje informacje która tablica była sortowana i w jakim czasie) Console.WriteLine($"Sorting list of tabs with length {list[0].Length}"); Stopwatch watch = new Stopwatch(); //Tworzenie obiektu klasy Stopwatch która będzie liczyć czas sortowania //kazda tablica z listy jest sortowana for (int i = 0; i < list.Count; i++) { watch.Start(); //Rozpoczęcie odliczania czasu pojedynczego sortowania switch (mode) { case 1: QuickSort.Sort(list[i], 0, list[i].Length - 1); break; case 2: ShellSort.Sort(list[i], list[i].Length); break; case 3: HeapSort.Sort(list[i], list[i].Length); break; } watch.Stop(); //Koniec odliczania czasu pojedynczego sortowania Console.WriteLine($"Tab nr {i} sort time {watch.ElapsedMilliseconds}"); Time time = new Time() { tabNumber = i, time = watch.ElapsedMilliseconds }; //Tworzę nowy obiekt klasy Time, zapisuje w nim informację o tym która tablica była sortowana oraz czas sortowania timeArray[i] = time; //Dodaje ten obiekt Time do tablicy Time'ów która na końcu będzie zapisana do pliku XML watch.Reset(); //Po każdej iteracji resetuje czas odliczania } XmlSerializer serializer = new XmlSerializer(typeof(TimeToSave)); /*Tworzę nowy obiekt klasy XmlSerializer * która posłuży do zapisania danych o czasie sortowań do pliku XML (w argumencie przekazuje typ obiektu jaki będzie zapisany do pliku XML) * czyli TimeToSave, w nim przechowam tablicę Time'ów którą stworzyłem na samym początku tej metody ("Time[] timeArray = new Time[list.Count]") */ TimeToSave timeArrayToSave = new TimeToSave() { time = timeArray }; //Tworzę obiekt TimeToSave i zapisuje w nim tablicę Time'ów //Zapisuje czasy sortowań do pliku XML, blok using sprawi że po zapisie, strumienie zostaną zamknięte dzięki czemu nie będzie problemów później z korzystaniem z pliku XML using (TextWriter writer = new StreamWriter($"TabsSortTimeLength{list[0].Length}.xml")) { serializer.Serialize(writer, timeArrayToSave); } Console.WriteLine($"List is sorted"); }
public static void Main() { var elements = Console.ReadLine() .Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries) .Select(int.Parse) .ToArray(); ShellSort <int> .Sort(elements, elements.Length); Console.WriteLine(string.Join(" ", elements)); }
public void ShellSortTest() { var shell = new ShellSort <int>(); shell.Items.AddRange(items); shell.Sort(); for (int i = 0; i < items.Count; i++) { Assert.AreEqual(sorted[i], shell.Items[i]); } }
public void SortNormally() { var array = new[] { 25, 17, 49, 1, 195, 58 }; var shellSort = new ShellSort(array); var result = shellSort.Sort().ToList(); Assert.AreEqual(1, result.First()); Assert.AreEqual(195, result.Last()); }
public void ShouldBeSorted(int[] input, string expect) { //Arrange var sut = new ShellSort(); //sut: system under test //Act var result = sut.Sort(input); //Assert Assert.Equal(expect, string.Join(',', result)); }
public void ShellSort_GivenUnsortedArray_SortedArray() { // Arrange int[] unsorted = new int[] { 4, 3, 2, 1, 5, 3 }; int[] expectedResult = new int[] { 1, 2, 3, 3, 4, 5 }; // Act ShellSort.Sort(unsorted); // Assert CollectionAssert.AreEqual(unsorted, expectedResult); }
public void ShellSortTest() { int[] result = CreateResultArray(); ShellSort <int> sort = new ShellSort <int>(result); result = sort.Sort(); for (int i = 0; i < array.Length; i++) { Assert.AreEqual(expected[i], result[i]); } }
public void TestShellSort() { var result = new int[_size]; Array.Copy(_unsorted, result, _size); ShellSort.Sort(result); for (int i = 0; i < result.Length; i++) { Assert.AreEqual(_sorted[i], result[i]); } }
public void ShellSortTest() { //arrange var ShellSort = new ShellSort <int>(dataList, "Shell"); //act ShellSort.Sort(); //assert for (int i = 0; i < count; i++) { Assert.AreEqual(sortedItems[i], ShellSort.Items[i]); } }
public void SortTestShell() { ShellSort <Int32> shell = new ShellSort <Int32>(); shell.Items.AddRange(list); shell.Sort(); for (Int32 i = 0; i < sorted.Length; i++) { Assert.AreEqual(sorted[i], shell.Items[i]); } }
public void SortWithComparerTest_DESC() { Point[] points = new Point[10]; for (int i = 0; i < 10; i++) { points[i] = new Point(i, 10 - i); } Shuffle.Do(points); Assert.IsFalse(SortHelper.IsSorted(points, Point.X_ORDER, SortOrder.DESC)); ShellSort.Sort(points, Point.X_ORDER, SortOrder.DESC); Assert.IsTrue(SortHelper.IsSorted(points, Point.X_ORDER, SortOrder.DESC)); }
public void ShellSortTest() { int[] unsorted = DataManager.GetUnsortedData(); int[] sorted = DataManager.GetSortedData(); ShellSort sort = new ShellSort(); sort.Sort(unsorted); for (int i = 0; i < unsorted.Length; i++) { Assert.AreEqual(unsorted[i], sorted[i]); } }
private void btnC4_Click(object sender, EventArgs e) { Ordenado = true; ListaAuxiliar = new List <int>(Lista); var t1 = DateTime.Now; ShellSort.Sort(ListaAuxiliar); var t2 = DateTime.Now; label4.Text = "Shell Sort = " + (t2 - t1).Milliseconds.ToString() + " ms"; CarregaGrid(ListaAuxiliar); VerificaBloqueiaCalcular(); btnDesord.Enabled = true; }
public void ShellSortTest() { // arrange var shell = new ShellSort <int>(); shell.Items.AddRange(Items); // act shell.Sort(); // assert for (int i = 0; i < shell.Items.Count; i++) { Assert.AreEqual(Sorted[i], shell.Items[i]); } }
public void Test(int[] data) { // Arrange int[] data2 = new int[data.Length]; Array.Copy(data, data2, data.Length); Array.Sort(data2); var sorter = new ShellSort <int>(); // Act sorter.Sort(data); // Assert CollectionAssert.AreEqual(data, data2); }
private void ShellSortButtonClick(object sender, EventArgs e) { if (progressBarCount < 2) { MessageBox.Show("нечего сортировать"); } else { var shell = new ShellSort <int>(); shell.Items.AddRange(values.Select(x => x.Bar.Value)); shell.SwapEvent += SwapEvent; var time = shell.Sort(); ShowInfoAboutSort(shell, time); } }
public void testSort() { var a = new int[100]; var b = new int[100]; for (var i = 0; i < a.Length; ++i) { a[i] = i; b[i] = i; } KnuthShuffle.Shuffle(a); Assert.NotEqual(b, a); ShellSort.Sort(a); Assert.Equal(b, a); }
public void ShellSort_Descending_Stress_Test() { var rnd = new Random(); var nodeCount = 1000; var randomNumbers = Enumerable.Range(1, nodeCount) .OrderBy(x => rnd.Next()) .ToList(); var result = ShellSort <int> .Sort(randomNumbers.ToArray(), SortDirection.Descending); for (int i = 0; i < nodeCount; i++) { Assert.AreEqual(randomNumbers.Count - i, result[i]); } }
public void ShellSort_Stress_Test() { var rnd = new Random(); var nodeCount = 1000; var randomNumbers = Enumerable.Range(1, nodeCount) .OrderBy(x => rnd.Next()) .ToList(); var result = ShellSort <int> .Sort(randomNumbers.ToArray()); for (int i = 1; i <= nodeCount; i++) { Assert.AreEqual(i, result[i - 1]); } }
public void ShellSortTest() { // arange var test = new ShellSort <int>(); test.Items.AddRange(Items); // act test.Sort(); // assert for (int i = 0; i < Sorted.Count; i++) { Assert.AreEqual(Sorted[i], test.Items[i]); } }
public static void ShellSort() { int[] arr; FileToArr(out arr); Console.WriteLine("- Danh sach ban dau lay tu File:"); Console.WriteLine("[{0}]", string.Join(", ", arr)); Console.WriteLine("- Danh sach sau khi duoc sap xep:"); var sw2 = Stopwatch.StartNew(); var sorter = new ShellSort(); sorter.Sort(arr); sw2.Stop(); Console.WriteLine("[{0}]", string.Join(", ", arr)); Console.WriteLine("Time taken ShellSort: {0} ms", sw2.Elapsed.TotalMilliseconds); Console.ReadKey(true); }
public void SellSort1() { var shellSort = new ShellSort(); Assert.IsTrue(shellSort.Add(43)); Assert.IsTrue(shellSort.Add(7)); Assert.IsTrue(shellSort.Add(11)); Assert.IsTrue(shellSort.Add(68)); Assert.IsTrue(shellSort.Add(55)); Assert.IsTrue(shellSort.Add(22)); Assert.IsTrue(shellSort.Add(102)); Assert.IsTrue(shellSort.Add(3)); shellSort.Sort(); Assert.IsTrue(shellSort.IsSorted()); }
private static void Sort(Algorithm algorithm, int[] array) { // Sort switch (algorithm) { case Algorithm.QuickSort: QuickSort.Sort(array, 0, array.Length - 1); break; case Algorithm.QuickSortV2: QuickSortV2.Sort(array, 0, array.Length - 1); break; case Algorithm.BubbleSort: BubbleSort.Sort(array); break; case Algorithm.InsertionSort: InsertionSort.Sort(array); break; case Algorithm.MergeSort: MergeSort.Sort(array); break; case Algorithm.SelectionSort: SelectionSort.Sort(array); break; case Algorithm.ShellSort: ShellSort.Sort(array); break; case Algorithm.HeapSort: HeapSort.Sort(array); break; case Algorithm.CombSort: CombSort.Sort(array); break; default: throw new NotSupportedException(); } }
public void ShellSortTest() { var sortedIntArray = _intArray.ToArray(); ShellSort.Sort(sortedIntArray); for (var i = 0; i < sortedIntArray.Length; i++) { Assert.AreEqual(_sortedIntArray[i], sortedIntArray[i]); } var sortedStringArray = _stringArray.ToArray(); ShellSort.Sort(sortedStringArray); for (var i = 0; i < sortedStringArray.Length; i++) { Assert.AreEqual(_sortedStringArray[i], sortedStringArray[i]); } }
public void ShellSortTest() { // Arrange var arrayCount = 0; foreach (var sample in GenerateSampleArrays()) { // Act ShellSort.Sort(sample); // Assert for (int i = 0; i < sample.Length - 1; i++) { Assert.True(sample[i] <= sample[i + 1], $"Array #{arrayCount} was not sorted."); arrayCount++; } } }
static void Main(string[] args) { Stopwatch stopwatch = new Stopwatch(); ShellSort shellSort = new ShellSort(); MergeSort mergeSort = new MergeSort(); QuickSort quickSort = new QuickSort(); int n = 1000; int nMultipleBy10 = 4; for (int i = 0; i < nMultipleBy10; i++) { Console.WriteLine("n=" + n); Transaction[] trans = TransactionGenerator.Generate(n); Transaction[] testCase = new Transaction[n]; trans.CopyTo(testCase, 0); stopwatch.Restart(); shellSort.Sort(testCase); stopwatch.Stop(); Console.WriteLine("Shell Sort: " + stopwatch.ElapsedMilliseconds + " ms"); trans.CopyTo(testCase, 0); stopwatch.Restart(); mergeSort.Sort(testCase); stopwatch.Stop(); Console.WriteLine("Merge Sort: " + stopwatch.ElapsedMilliseconds + " ms"); trans.CopyTo(testCase, 0); stopwatch.Restart(); quickSort.Sort(testCase); stopwatch.Stop(); Console.WriteLine("Quick Sort: " + stopwatch.ElapsedMilliseconds + " ms"); trans.CopyTo(testCase, 0); stopwatch.Restart(); Heap.Sort(testCase); stopwatch.Stop(); Console.WriteLine("Heap Sort: " + stopwatch.ElapsedMilliseconds + " ms"); n *= 10; } }
public void SortTest() { //arrenge var shell = new ShellSort <int>(); var rnd = new Random(); var items = new List <int>(); for (int i = 0; i < 15; i++) { items.Add(rnd.Next(0, 100)); } shell.Items.AddRange(items); var sorted = items.OrderBy(x => x).ToArray();//стадартная сортировка List //act shell.Sort(); //assert for (int i = 0; i < items.Count; i++) { Assert.AreEqual(sorted[i], shell.Items[i]); } }
public static long getSortTime(SORT_TYPE type, int[] array) { var attempts = new long[Form1.ATTEMPTS]; for (var j = 0; j < Form1.ATTEMPTS; j++) { switch (type) { case SORT_TYPE.SORT: myStopwatch.Restart(); Array.Sort(array); myStopwatch.Stop(); break; case SORT_TYPE.QUICKSORT: Quicksort<int> q = new Quicksort<int>(); myStopwatch.Restart(); q.QSort(array); myStopwatch.Stop(); break; case SORT_TYPE.HEAPSORT: Heapsort h = new Heapsort(); myStopwatch.Restart(); h.heapSort(array); myStopwatch.Stop(); break; case SORT_TYPE.SHELLSORT: ShellSort<int> s = new ShellSort<int>(); myStopwatch.Restart(); s.Sort(array); myStopwatch.Stop(); break; default: throw new Exception("Unknown error"); } attempts[j] = myStopwatch.ElapsedMilliseconds; } Array.Sort(attempts); return attempts[Form1.ATTEMT_NUMBER_TO_USE-1]; }