public void ShouldReturnAlreadySortedList() { var expected = Enumerable.Range(0, 1000).ToArray(); var actual = Algorithm.Sort(expected); Assert.Equal(expected, actual); }
public async Task Test(ISortAlgorithm algorithm) { Assert.Equal(new int [] { 2, 4 } as IEnumerable <int>, await algorithm.Sort(new int [] { 4, 2 })); var random = new System.Random(); var random_list = Enumerable.Repeat(0, 1000) .Select(i => random.Next(1, 10)).ToList(); IEnumerable <int> expected = random_list.OrderBy(i => i); Assert.Equal(expected, await algorithm.Sort(random_list)); }
static void Main(string[] args) { try { //Console.WriteLine("Please enter your comma separated integer array list. eg: 5,8,3"); //string arrayString = Console.ReadLine(); /*Console.ForegroundColor = ConsoleColor.Yellow; * Console.WriteLine("Yelow: Comparing"); * Console.ForegroundColor = ConsoleColor.Red; * Console.WriteLine("Red: Exchanged"); * Console.ForegroundColor = ConsoleColor.Green; * Console.WriteLine("Green: Not Exchanged\n"); * Console.ResetColor();*/ string arrayString = "8,7,1,3,6,4,6"; string[] tokens = arrayString.Split(','); int[] array = Array.ConvertAll(tokens, int.Parse); Console.WriteLine("Select sort type. Enter one of the number from options"); foreach (var value in Enum.GetValues(typeof(SortType))) { string name = Enum.GetName(typeof(SortType), value); Console.WriteLine("{0} {1}", Convert.ToInt32(value), name); } var selectedOption = Convert.ToInt32(Console.ReadLine()); ISortAlgorithm alg = SortFactory.GetSortAlgorithm((SortType)selectedOption); alg.Sort(array); Console.WriteLine("Final: {0}", string.Join(",", array)); Console.WriteLine("Done"); } catch (Exception ex) { Console.Write(ex.Message); } Console.ReadKey(); }
private void SortStartExecute(object obj) { //dynamically create SortAlgorithm instance, from the selected type ISortAlgorithm sortAlgorithm = (ISortAlgorithm)Activator.CreateInstance(SelectedSortAlgorithm); //start sorting in a new thread Task.Run(() => sortAlgorithm.Sort(SortCollection)); }
/// <inheritdoc /> public void Sort(ISortAlgorithm algorithm, IComparer comparable) { var array = new object[Count]; CopyTo(array, 0); algorithm.Sort(array, comparable); Array.Copy(array, _array, Count); }
public void SortSessions(IConference conference, List <SessionDisplayModel> sessions) { if (conference.CanVote()) { _votingSort.Sort(sessions); } else { _defaultSort.Sort(sessions); } }
public object Do() { ISortAlgorithm sortAlgorithm = SortAlgorithmFactory.CreateAlgorithm(_model, _element, _algorithm); SortResult sortResult = sortAlgorithm.Sort(); _model.ReorderChildren(_element, sortResult); _order = sortResult.Data; _model.AssignElementOrder(); return(null); }
private void SortBuckets(IEnumerable <List <string> > buckets, CancellationToken cancellationToken) { foreach (var bucket in buckets.Where(b => b.Any())) { cancellationToken.ThrowIfCancellationRequested(); var toSort = bucket.ToArray(); _sortAlgorithm.Sort(toSort); bucket.Clear(); bucket.AddRange(toSort); } }
private List <string> SortBuckets(List <string>[] buckets) { var sorted = new List <string>(); foreach (var bucket in buckets) { var toSort = bucket.ToArray(); _sortAlgorithm.Sort(toSort); sorted.AddRange(toSort); } return(sorted); }
private void Partition(IProgress <ProgressInfo> progress, IDsmElement element, int totalElements, ref int progressedElements) { ISortAlgorithm algorithm = SortAlgorithmFactory.CreateAlgorithm(_dsmModel, element, PartitionSortAlgorithm.AlgorithmName); _dsmModel.ReorderChildren(element, algorithm.Sort()); progressedElements++; UpdateProgress(progress, "Partition elements", totalElements, progressedElements); foreach (IDsmElement child in element.Children) { Partition(progress, child, totalElements, ref progressedElements); } }
private static void AssertSort(int[] array, ISortAlgorithm sortAlgorithm) { var copy = new int[array.Length]; array.CopyTo(copy, 0); sortAlgorithm.Sort(copy); var orderedArray = array.OrderBy(x => x).ToArray(); for (var i = 0; i < orderedArray.Length; ++i) { Assert.AreEqual(orderedArray[i], copy[i], $"Invalid element in position: {i} of array: {string.Join(",", array)}s"); } }
private void SortBuckets(IEnumerable <List <string> > buckets, CancellationToken cancellationToken) { foreach (List <string> bucket in buckets) { cancellationToken.ThrowIfCancellationRequested(); if (bucket.Any() == false) { continue; } string[] toSort = bucket.ToArray(); _sortAlgorithm.Sort(toSort); bucket.Clear(); bucket.AddRange(toSort); } }
public SortResult <T> OrderObjects <T>(IEnumerable <T> objectsToOrder, ISortAlgorithm <T> sortAlgorithm) where T : AbstractComparable <T> { if (objectsToOrder == null) { throw new ArgumentNullException(nameof(objectsToOrder)); } if (sortAlgorithm == null) { throw new ArgumentNullException(nameof(sortAlgorithm)); } var lowerRanks = objectsToOrder.ToDictionary(k => k, v => new List <T>()); foreach (var o in objectsToOrder) { foreach (var hO in o.HigherRankedObjects) { List <T> lowerRankList = null; if (lowerRanks.TryGetValue(hO, out lowerRankList)) { lowerRankList.Add(o); } } } var results = objectsToOrder .OrderBy(o => o.HigherRankedObjects.Count) .ThenBy(o => lowerRanks[o].Count) .ToArray(); T left = null; T right = null; SortResult <T> sortResult; try { sortResult = sortAlgorithm.Sort(results); } catch (UnknownComparisonException <T> exception) { // TODO: Add check that result is the correct length left = exception.Left; right = exception.Right; sortResult = new SortResult <T>(results, left, right); } return(sortResult); }
public List <Job> GetOrderedJobList(string jobsString) { if (!_stringValidator.IsValidString(jobsString)) { throw new Exception("Error: wrong syntax"); } var jobs = _jobsBuilder.GetJobList(jobsString); if (!_jobsValidator.IsValidListOfJobs(jobs)) { throw new Exception("Error: the job list is not coherent"); } return(_sortAlgorithm.Sort(jobs)); }
public void ExecuteSort_StaticArray_ReturnsSortedArray(ISortAlgorithm <int> sortAlgorithm) { List <int> staticList = new List <int> { 10, 3, 2, 11, 1, 0, 0 }; IEnumerable <int> sortedCollection = sortAlgorithm.Sort(staticList); Assert.That(sortedCollection, Is.Ordered); }
public static void DoTests(IComparable[] arr, ISortAlgorithm sorter) { var isSorted = TestHelper.IsSortedAsc(arr); Assert.IsFalse(isSorted); isSorted = TestHelper.IsSortedDesc(arr); Assert.IsFalse(isSorted); sorter.Sort(arr); isSorted = TestHelper.IsSortedAsc(arr); Assert.IsTrue(isSorted); arr = arr.Reverse().ToArray(); isSorted = TestHelper.IsSortedDesc(arr); Assert.IsTrue(isSorted); }
/// <summary> /// Sorts the specified IList(Of T) using the algorithm specified in the order specified. /// </summary> /// <typeparam name="T">type of the elements in toSort</typeparam> /// <param name="toSort">the list to sort.</param> /// <param name="algorithm">The algorithm to use.</param> /// <param name="direction">The direction to sort the elements in.</param> /// <param name="startIndex">The start index.</param> /// <param name="endIndex">The end index.</param> /// <param name="compareFunc">The compare func to compare two elements in the list to sort.</param> public static void Sort <T>(this IList <T> toSort, SortAlgorithm algorithm, SortDirection direction, int startIndex, int endIndex, Comparison <T> compareFunc) { if (toSort.IsNullOrEmpty() || (toSort.Count == 1)) { return; } int startIndexToUse = startIndex; int endIndexToUse = endIndex; if (startIndexToUse < 0) { startIndexToUse = 0; } if (startIndexToUse >= toSort.Count) { throw new IndexOutOfRangeException(string.Format("startIndex's value {0} is outside the list to sort, which has {1} values.", startIndexToUse, toSort.Count)); } if (endIndexToUse < 0) { endIndexToUse = toSort.Count - 1; } if (endIndexToUse >= toSort.Count) { throw new IndexOutOfRangeException(string.Format("endIndex's value {0} is outside the list to sort, which has {1} values.", endIndexToUse, toSort.Count)); } Comparison <T> comparisonToUse = compareFunc; if (compareFunc == null) { comparisonToUse = GeneralUtils.GetUsableComparison <T>(null); } ISortAlgorithm sorter = SortAlgorithmFactory.CreateSortAlgorithmImplementation(algorithm); if (sorter != null) { sorter.Sort(toSort, direction, startIndexToUse, endIndexToUse, comparisonToUse); } }
public T[] Sort() { return(_sortAlgorithm.Sort <T>(_items.ToArray())); }
public static int[] HelperSort(ISortAlgorithm algorithm, int[] unsorted) { return(algorithm.Sort(unsorted)); }
protected void SortSubArray(ref T[] subArr) { SortAlgorithm.Sort(ref subArr); }