前 注：
这是自己平时根据自己需要写的一些小代码，为了避免再次数据丢失，所以放到网上来，未必对各看官有用。另外，这是根据个人想法而写，未必严谨和符合设计原则，若有任何不妥之处，还请不吝赐教。
说 明：
对于排序或查找算法而言，这些代码复用的一个难点在于：算法逻辑和数据集操作的代码是耦合在一起的。导致即使算法逻辑一样，但因为数据集类型的差异，也不得不重新实现整个算法。而我们所想要的算法复用，其实是算法逻辑的复用。因此，要复用算法，关键在于把算法逻辑抽取出来。由于一般情况下，算法的结构是数据集操作嵌入到算法逻辑过程中，因此，若能为数据集操作抽象出统一的接口，则算法逻辑就可以通用了。
如何为数据集操作抽象一个接口，应该为数据集定义一个基类吗？显然不可行，虽然.NET有一些集合类型的基础接口，但这些接口基本上没有提供排序所需操作的方法。而且并非所有的类型都有相同的基类型。因此，要抽象操作数据的接口，必须换个角度。
对于大部排序算法来说，涉及对数据集的操作无外乎：一、比较数据集中两个值；二、交换数据集中的两个值。只需设计这两个操作的接口即可。显然，如何比较比较数据要依数据类型和业务要求而定，而如何交换数据的值则与数据集结构和数据类型有关。另一方面，其实算法所决定的只有一点：要比较或交换的数据的位置，算法所关心的也只有一点：比较操作的结果（即返回值）。
综上，可以抽象一个这样的数据操作接口：一、比较，接受两个索引，返回比较结果；二、交换，接受两个索引，无返回值。算法调用这两个接口并传入索引，调用方负责实现比较两个索引处的值和交换两个索引处的值。
对于C#而言，此接口可以使用委托实现，而对于Java，则只能使用Interface来实现。相对来说，委托实现简洁一点，使用方需要做的工作也少一点，效率也应该会高一点。另外，对于快速排序，其实只需要一个数据源的双向迭代访问器即可，不过这样实现起来想来应该比上述方法要繁琐一点。
示 例：
class QuickSortTest
{
static byte[] Array;
static Random Random = new Random();
static QuickSorter QuickSorter = new QuickSorter();
public static void Swap(int IdxA, int IdxB)
{
byte Temp = Array[IdxA];
Array[IdxA] = Array[IdxB];
Array[IdxB] = Temp;
}
public static int Compare(int IdxA, int IdxB)
{
return Array[IdxA] - Array[IdxB];
}
public static void Test()
{
int TestTimes = 1000;
while (--TestTimes > 0)
{
Array = new byte[Random.Next(50)];
Random.NextBytes(Array);
Console.Write("\r\nBefore Sort : ");
foreach (byte Data in Array)
{
Console.Write(Data.ToString() + '\t');
}
QuickSorter.QuickSort(0, Array.Length - 1, Compare, Swap);
Console.Write("\r\nAfter Sort : ");
foreach (byte Data in Array)
{
Console.Write(Data.ToString() + '\t');
}
if (Array.Length <= 1) continue;
for (int Idx = 0; Idx < Array.Length - 1; Idx++)
{
if (Array[Idx] > Array[Idx + 1])
Console.Write("\r\nSort Error");
}
}
}
}
原 码：
public class QuickSorter
{
public delegate int CompareDelegate(int IdxA, int IdxB);
public delegate void SwapDelegate(int IdxA, int IdxB);
private CompareDelegate Comparer;
private SwapDelegate Swaper;
public int QuickSort(int LBound, int UBound, CompareDelegate Comparer, SwapDelegate Swaper)
{
this.Comparer = Comparer;
this.Swaper = Swaper;
QuickSort(LBound, UBound);
return 1;
}
private int QuickSort(int LBound, int UBound)
{
if (UBound - LBound < 1) return 0;
int ForwardPointr = LBound, BackwardPointer = UBound + 1;
//注：以第一个元素为参考
while (ForwardPointr < BackwardPointer)
{
//从前往找第一个大于参考的数
while (++ForwardPointr < BackwardPointer && Comparer(LBound, ForwardPointr) >= 0) ;
//从后往找第一个小于等于参考的数
while (--BackwardPointer > ForwardPointr && Comparer(LBound, BackwardPointer) < 0) ;
//如果找到，则交换值
if (ForwardPointr < BackwardPointer) Swaper(BackwardPointer, ForwardPointr);
}
//将参考值换到中间
Swaper(LBound, --ForwardPointr);
QuickSort(LBound, ForwardPointr - 1);
QuickSort(ForwardPointr + 1, UBound);
return 1;
}
}