Comments on: C# Stable Sort

By: Pradeep

Pradeep — Tue, 23 Feb 2010 08:46:46 +0000

Brillaint!!!!! Thanks a lot!!!!!

By: Joseph Johnson Jr.

Joseph Johnson Jr. — Thu, 11 Jun 2009 18:52:41 +0000

BTW, I really like how the author has properly laid out the sort using generic types as it makes other convenient methods possible (such as delegate comparison functions). For those that do not want to explicitly implement the CompareTo method in their class (let's say you have various keys you want to sort on determined at runtime, such as the columns in a gridview), you can use the author's sort method like this:

// or name, etc, determined at runtime.
string SortKey = "age";
InsertionSort(list, delegate(Person a, Person b) { if (SortKey == "name") return a.Name.CompareTo(b.Name); else if (SortKey == "age") return a.Name.CompareTo(b.Name); });

You can see how the anonymous delegate has scope over your SortKey variable which can be the user's custom sort expression. Very useful stuff here especially when combined with the power of the .NET GridView control.

If yo uwant to reverse the sort direction, pass in a flag that tells you what the sort direction is (ascending or descending) and simply flip the person objects around:

bool AscendingSort = false;
// or name, etc, determined at runtime.
string SortKey = "age";

InsertionSort(list, delegate(Person a, Person b) {
if (SortKey == "name") {
if (AscendingSort) return a.Name.CompareTo(b.Name);
else return b.Name.CompareTo(a.Name);
} else if (SortKey == "age") {
if (AscendingSort) return a.Age.CompareTo(b.Age);
else return b.Age.ComapreTo(a.Age);
}
return 0;
});

By: Joseph Johnson Jr.

Joseph Johnson Jr. — Thu, 11 Jun 2009 18:31:59 +0000

Just what I was looking for. I too ran into the .NET quicksort stability problem. Insertion sort, although it is of higher time complexity O(N^2) than quicksort's O(nlogn), ends up being better in practice for smaller collections as there is less overhead (space complexity for one, as this is an in-place algorithm) than, say, merge sort or heap sort. And of course it's stable. Also it is said to be "adaptive" so if the data is "nearly sorted" it can outperform other DAC (divide and conquer) algorithms like merge sort. In fact you'll often see "hybrid" sort algorithms using insertion sort when the problem size is small. For large collections, no contest: merge sort.

By: List.Sort() uses QuickSort which if two elements are equal, their order might not be preserved « Ezra’s Blog

Wed, 04 Mar 2009 23:24:36 +0000

[...] http://www.csharp411.com/c-stable-sort/ [...]

By: Haroon Sarwar

Haroon Sarwar — Wed, 21 Jan 2009 05:44:20 +0000

Check out PowerCollections (http://www.wintellect.com/PowerCollections.aspx) for a stable sort implementation and many other useful functions…

(Source code is available)

By: matjaz

matjaz — Thu, 28 Aug 2008 09:29:35 +0000

Good, but there are much better stable sorts available, for example MergeSort and Binary tree sort, both of which have the same average time complexity as QuickSort (n log n).
See http://en.wikipedia.org/wiki/Stable_sort#Classification

By: uros

uros — Thu, 24 Jan 2008 11:09:24 +0000

Excellent!