通用快速排序算法

前 注：

这是自己平时根据自己需要写的一些小代码，为了避免再次数据丢失，所以放到网上来，未必对各看官有用。另外，这是根据个人想法而写，未必严谨和符合设计原则，若有任何不妥之处，还请不吝赐教。

说 明：

对于排序或查找算法而言，这些代码复用的一个难点在于：算法逻辑和数据集操作的代码是耦合在一起的。导致即使算法逻辑一样，但因为数据集类型的差异，也不得不重新实现整个算法。而我们所想要的算法复用，其实是算法逻辑的复用。因此，要复用算法，关键在于把算法逻辑抽取出来。由于一般情况下，算法的结构是数据集操作嵌入到算法逻辑过程中，因此，若能为数据集操作抽象出统一的接口，则算法逻辑就可以通用了。
如何为数据集操作抽象一个接口，应该为数据集定义一个基类吗？显然不可行，虽然.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;
        }
    }