static void Main(string[] args) { System.Console.WriteLine("hello world!"); Random random = new Random(); //int[] myArray = new int[] { 45, 36, 36, 18, 53, 72, 30, 48, 93, 15}; int[] myArray = new int[10]; string strArray = ""; for (int i = 0; i < myArray.Length; i++) { myArray[i] = random.Next(1, 100); strArray = strArray + myArray[i] + " "; } print("=================:" + strArray); SortFunc sf = new SortFunc(); //排序 //sf.BubbleSort(myArray, SortType.Ascending); //sf.InsertSort(myArray, SortType.Descending); //sf.QuickSort(myArray, SortType.Ascending); //sf.SimpleSelectSort(myArray, SortType.Ascending); sf.ShellSort(myArray, SortType.Descending); //print("myArray.Length{0}", myArray.Length); for (int i = 0; i < myArray.Length; i++) { print("{0}", myArray[i]); } System.Console.ReadLine(); }
/// <summary> /// Sorts the specified list. /// </summary> /// <typeparam name="P"></typeparam> /// <param name="list">The list.</param> /// <param name="lambda">The lambda.</param> /// <param name="descending">if set to <c>true</c>, then sorts the list in descending order.</param> public void Sort <P>(List <T> list, SortFunc <T, P> lambda, bool descending) where P : IComparable <P> { // Apply and set the sort, if items to sort list.Sort(delegate(T x, T y) { // Get property values P xValue = lambda(x); P yValue = lambda(y); // Do comparison int result; if (xValue == null) { result = (yValue == null) ? 0 : 1; } else { result = xValue.CompareTo(yValue); } // return based on direction return((descending) ? -(result) : result); }); }
/// <summary> /// Sorts the collection based on a specified lambda expression. /// </summary> /// <typeparam name="P"></typeparam> /// <param name="lambda">The lambda expression.</param> /// <param name="descending">if set to <c>true</c>, then sorts then collection in descending order.</param> public void Sort <P>(SortFunc <T, P> lambda, bool descending) where P : IComparable <P> { // get sorter and sort var sorter = new ListSorter <T>(); sorter.Sort(Items as List <T>, lambda, descending); }
/// <summary> /// Sorts the collection based on a specified lambda expression. /// </summary> /// <typeparam name="P"></typeparam> /// <param name="lambda">The lambda expression.</param> public void Sort <P>(SortFunc <T, P> lambda) where P : IComparable <P> { // get sorter and sort var sorter = new ListSorter <T>(); sorter.Sort(Items as List <T>, lambda, false); }
public int Compare(string[] x, string[] y) { int index = 0; int retval = 0; while ((retval == 0) && (index < sorttype.Count))//如果比较相等且比较函数未到最后一个 { SortFunc func = (SortFunc)SortFuncHandle[sorttype[index]]; retval = func(x, y); index++; } return(retval); }
//初始化排序方法列表 public void InitTable() { if (sorttype.Count == 0) { sorttype.Add(SortPolicy.MinHops); SortFunc MinHops = SortByMinHops; SortFuncHandle.Add(SortPolicy.MinHops, MinHops); } else { foreach (SortPolicy sp in sorttype) { switch (sp) { case SortPolicy.MinHops: SortFunc MinHops = SortByMinHops; if (!SortFuncHandle.ContainsKey(SortPolicy.MinHops)) { SortFuncHandle.Add(SortPolicy.MinHops, MinHops); } break; case SortPolicy.MinMaxDist: SortFunc MinMax = SortByMinMaxDist; if (!SortFuncHandle.ContainsKey(SortPolicy.MinMaxDist)) { SortFuncHandle.Add(SortPolicy.MinMaxDist, MinMax); } break; case SortPolicy.TotalDist: SortFunc TotalDist = SortByTotalDist; if (!SortFuncHandle.ContainsKey(SortPolicy.TotalDist)) { SortFuncHandle.Add(SortPolicy.TotalDist, TotalDist); } break; default: MinHops = SortByMinHops; if (!SortFuncHandle.ContainsKey(SortPolicy.MinHops)) { SortFuncHandle.Add(SortPolicy.MinHops, MinHops); } break; } } } }
/// <summary> /// 排序并返回列表。 /// </summary> public System.Collections.Generic.List <DatabaseSchemaHandler> Sort() { System.Collections.Generic.List <DatabaseSchemaHandler> list = new System.Collections.Generic.List <DatabaseSchemaHandler>(); //foreach(AssemblyRef System.Collections.Generic.Dictionary <string, SortEntry> refOrders = new System.Collections.Generic.Dictionary <string, SortEntry>(); System.Collections.Generic.List <AssemblyRef> all = LinqHelper.ToList(_refs.Values); SortAction action = null; action = (p1, p2) => { foreach (string p11 in p1.refs) { AssemblyRef p12; if (_refs.TryGetValue(p11, out p12)) { if (all.Remove(p12)) { action(p12, p2 * 1000); } } } SortEntry p10 = new SortEntry() { item = p1, order = p2 * (refOrders.Count + 1) }; refOrders.Add(p1.fullName, p10); return(p10); }; while (all.Count > 0) { AssemblyRef item = all[0]; all.RemoveAt(0); action(item, -1); } SortFunc classOrderGetter = (p1) => p1.Attribute.Order + GetClassRef(p1.Attribute.TableName, p1.Attribute.References); foreach (SortEntry p1 in LinqHelper.OrderByDescending(refOrders.Values, p => p.order)) { list.AddRange(p1.item.SortList(classOrderGetter)); } refOrders.Clear(); refOrders = null; all = null; return(list); }
private static int[][] BubbleSort(int[][] array, SortFunc sortFunc, IComparer comparer) { int[] buf = null; int arrayLength = array.Length; for (int i = 0; i < arrayLength; i++) { for (int j = i + 1; j < arrayLength; j++) { if (comparer.Compare(sortFunc(array[i]), sortFunc(array[j])) == 1) { buf = array[i]; array[i] = array[j]; array[j] = buf; } } } return(array); }
public static void ShowTestsFunc(SortFunc sortFunc) { var stopwatch = new Stopwatch(); var testData = new Dictionary <int[], string>() { { new[] { 1, 3, 2, 0, -1, 10, 4, 456 }, "O(n^2)" }, { new[] { 1, 2, 3, 4, 5, 6, 7, 8 }, "O(n)" }, }; foreach (KeyValuePair <int[], string> data in testData) { Console.WriteLine($"Time complexity: {data.Value}"); Console.WriteLine($"Before sorting : {string.Join(" ", data.Key)}"); stopwatch.Restart(); sortFunc(data.Key); stopwatch.Stop(); Console.Write($"{sortFunc.Method.Name,-25} |After sorting: {string.Join(" ", data.Key),-10} "); Console.WriteLine("|ElapseTicks: " + stopwatch.ElapsedTicks); } Console.WriteLine(new string('-', 65)); }
/// <summary> /// Sorts the specified list. /// </summary> /// <typeparam name="P"></typeparam> /// <param name="list">The list.</param> /// <param name="lambda">The lambda.</param> public void Sort <P>(List <T> list, SortFunc <T, P> lambda) where P : IComparable <P> { Sort(list, lambda, false); }
internal void Register(SortFunc sortFunc) { this.sortFunc = sortFunc; }
public ManagedJobList ReInitialize(DiscoDataContext Database, FilterFunc FilterFunction, SortFunc SortFunction, bool FilterAuthorization) { if (Database == null) throw new ArgumentNullException("Database"); lock (updateLock) { if (FilterFunction != null) this.FilterFunction = FilterFunction; if (SortFunction != null) this.SortFunction = SortFunction; base.Items = this.SortFunction(this.DetermineItems(Database, this.FilterFunction(Database.Jobs), FilterAuthorization)).ToList(); } return this; }
public ManagedJobList(string Name, FilterFunc FilterFunction, SortFunc SortFunction) { this.Name = Name; this.FilterFunction = FilterFunction; this.SortFunction = SortFunction; }
public System.Collections.Generic.IEnumerable <DatabaseSchemaHandler> SortList(SortFunc classOrderGetter) { return(LinqHelper.Where(list, p => p.Attribute.IsValid) .OrderBy(p => p.Attribute.Type) .ThenBy(p => classOrderGetter(p)) .ThenBy(p => p.Attribute.TableName)); }