C# program to Implements the well-known quick sort algorithm

 using System;  
 using System.Collections.Generic;  
 using System.Linq;  
 using System.Text;  
 using System.Threading.Tasks;  
 namespace SharpMap.Utilities  
 {  
   /// <summary>  
   /// Implements the well-known quick sort algorithm.  
   /// </summary>  
   public static class QuickSort  
   {  
     /// <summary>  
     /// Sorts a list in-place, given the <paramref name="comparison"/>  
     /// method.  
     /// </summary>  
     /// <typeparam name="T">Type of element in the list.</typeparam>  
     /// <param name="list">The list to sort.</param>  
     /// <param name="comparison">The method used to compare list elements.</param>  
     public static void Sort<T>(IList<T> list, Comparison<T> comparison)  
     {  
       if (list == null) throw new ArgumentNullException("list");  
       if (comparison == null) throw new ArgumentNullException("comparison");  
       if (list.Count < 2)  
       {  
         return;  
       }  
       Int32 middle = (list.Count - 1) / 2;  
       Int32 partitionIndex = partition(list, comparison, 0, list.Count - 1, middle);  
       sortRange(list, comparison, 0, partitionIndex);  
       sortRange(list, comparison, partitionIndex + 1, list.Count - 1);  
     }  
     private static Int32 partition<T>(IList<T> list, Comparison<T> comparison,  
       Int32 minIndex, Int32 maxIndex, Int32 pivotIndex)  
     {  
       T pivotItem = list[pivotIndex];  
       swap(list, pivotIndex, maxIndex);  
       Int32 minCompareIndex = minIndex - 1;  
       for (Int32 i = minIndex; i <= maxIndex - 1; i++)  
       {  
         if (comparison(list[i], pivotItem) < 0)  
         {  
           minCompareIndex++;  
           swap(list, minCompareIndex, i);  
         }  
       }  
       minCompareIndex++;  
       swap(list, maxIndex, minCompareIndex);  
       return minCompareIndex;  
     }  
     private static void sortRange<T>(IList<T> list, Comparison<T> comparison, Int32 minIndex, Int32 maxIndex)  
     {  
       if (minIndex >= maxIndex)  
       {  
         return;  
       }  
       Int32 middle = (maxIndex - minIndex) / 2 + minIndex;  
       Int32 partitionIndex = partition(list, comparison, minIndex, maxIndex, middle);  
       sortRange(list, comparison, minIndex, partitionIndex);  
       sortRange(list, comparison, partitionIndex + 1, maxIndex);  
     }  
     private static void swap<T>(IList<T> list, Int32 minIndex, Int32 maxIndex)  
     {  
       T item = list[minIndex];  
       list[minIndex] = list[maxIndex];  
       list[maxIndex] = item;  
     }  
   }  
 }