快排，堆排 C#實現

        /// <summary>
        /// 堆排序
        /// </summary>
        /// <param name="R"></param>
        public static void HEAPSORT(int[] R)
        {
            //建初始大根堆
            for (int i = R.Length / 2 + Convert.ToInt32(Math.IEEERemainder(R.Length, 2)); i > 0; i--)
            {
                SIFT(R, i - 1, R.Length - 1);
            }
            //迴圈進行交換並重建大根堆
            for (int j = R.Length - 1; j > 0; j--)
            {
                //交換根和無序區最後一個數
                int t = R[0]; R[0] = R[j]; R[j] = t;
                SIFT(R, 0, j - 1);
            }
        }
        public static void SIFT(int[] R, int iFrom, int iTo)
        {
            int i = iFrom;            //根結點下標
            int j = 2 * iFrom + 1;    //左孩子下標
            int temp = R[i];          //要調整的根結點,假定左右子樹已為大根堆
            while (j <= iTo)
            {
                if ((j < iTo) && ((R[j] < R[j + 1])))
                {
                    j++;//如果右孩子大於左孩子,將j指向右孩子,以便接下來統一處理
                }
                if ((R[j] > temp))
                {
                    //比根結點大的孩子上移
                    R[i] = R[j];
                    //指向下一個子樹
                    i = j;
                    j = 2 * i + 1;
                }
                else
                {
                    break;
                }
            }
            //定位要當初的根結點到正確的位置
            R[i] = temp;
        }

        //---------------------------------------------------------------------------------

        /// <summary>
        /// 快速排序演算法
        /// </summary>
        /// 快速排序為不穩定排序,時間複雜度O(nlog2n),為同數量級中最快的排序方法
        /// <param name="arr">劃分的數組</param>
        /// <param name="low">數組低端上標</param>
        /// <param name="high">數組高端下標</param>
        /// <returns></returns>
        static int Partition(int[] arr, int low, int high)
        {
            //進行一趟快速排序,返回中心軸記錄位置
            // arr[0] = arr[low];
            int pivot = arr[low];//把中心軸置於arr[0]
            while (low < high)
            {
                while (low < high && arr[high] >= pivot)
                {
                    --high;
                }
                Swap(ref arr[high], ref arr[low]);//將比中心軸記錄小的移到低端
                while (low < high && arr[low] <= pivot)
                {
                    ++low;
                }
                Swap(ref arr[high], ref arr[low]);//將比中心軸記錄大的移到高端
                
            }
            arr[low] = pivot; //中心軸移到正確位置
            return low;  //返回中心軸位置
        }
        static void Swap(ref int i, ref int j)
        {
            int t;
            t = i;
            i = j;
            j = t;
        }
        static void QuickSort(int[] arr, int low, int high)
        {
            if (low < high - 1)//當 arr[low,high]為空白或只一個記錄無需排序
            {
                int pivot = Partition(arr, low, high);
                QuickSort(arr, low, pivot - 1);
                QuickSort(arr, pivot + 1, high);

            }
        }