常用排序（C#实现）

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

 

namespace TestSort

{

    class Sort

    {

        //================归并排序============

        public static void MergeSort(int[] arr, int start, int end)

        {

            if (start < end)

            {

                int middle = (start + end) / 2;

                MergeSort(arr,start,middle);

                MergeSort(arr,middle+1,end);

                MergeSort(arr,start,middle,end);

            }

        }

 

        public static void MergeSort(int[] arr, int start, int middle, int end)

        {

            int[] tmp = new int[end - start + 1];

            int i = start;

            int j = middle + 1;

            int k = 0;

 

            while (i <= middle && j <= end)

            {

                if (arr[i] < arr[j])

                {

                    tmp[k] = arr[i];

                    k++;

                    i++;

                }

                else

                {

                    tmp[k] = arr[j];

                    k++;

                    j++;

                }

            }

 

            while (i <= middle)

            {

                tmp[k] = arr[i];

                k++;

                i++;

            }

 

            while (j <= end)

            {

                tmp[k] = arr[j];

                k++;

                j++;

            }

 

            for (k = 0, i = start; i <= end; k++, i++)

                arr[i] = tmp[k];

 

        }

 

        //==================希尔排序===============

        public static void ShellSort(int[] arr)

        {

            int gap = arr.Length / 2;

            int tmp;

            while (gap > 0)

            {

                for (int i = 0; i < arr.Length; i++)

                {

                    tmp = arr[i];

                    int j;

                    for(j = i-gap;j >= 0 ;j-=gap)

                    {

                        if (arr[j] > tmp)

                            arr[j + gap] = arr[j];

                        else                           

                            break;

                    }

                    arr[j + gap] = tmp;

                }

                gap /= 2;

            }

        }

        //===============基数排序===============

        public static void RadixSort(int[] arr)

        {

            int MaxLength = 1;    //最大数的位数

            int tmp,num,i,j;

            List<int>[] list = new List<int>[10];

            for (i = 0; i < 10;i++ )

                list[i] = new List<int>();

                for (i = 0; i < arr.Length; i++)

                {

                    num = arr[i];

                    tmp = 0;

                    while (num != 0)

                    {

                        tmp++;

                        num /= 10;

                    }

                    if (tmp > MaxLength)

                        MaxLength = tmp;

                }

 

            for (i = 0; i < MaxLength; i++)

            {

                for (j = 0; j < arr.Length; j++)

                {

                    num = arr[j];

                    tmp = i;

                    while (tmp > 0)

                    {

                        num /= 10;

                        tmp--;

                    }

                    tmp = num % 10;   //第i+1位上的数

                    list[tmp].Add(arr[j]);

                }

                tmp = 0;

                for (j = 0; j < 10; j++)

                {

                    foreach (int k in list[j])

                    {

                        arr[tmp] = k;

                        tmp++;

                    }

                    list[j].Clear();

                }

            }

        }

 

        //=================快排=====================

        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)//当 arr[low,high]为空或只一个记录无需排序

            {

                int pivot = Partition(arr, low, high);

                QuickSort(arr, low, pivot - 1);

                QuickSort(arr, pivot + 1, high);

 

            }

        }

        //================堆排序====================

        public static void HeapSort(int[] arr)

        {

 

            BuildMaxHeap(arr);

 

            for (int i = (arr.Length - 1); i > 0; i--)

            {

                Swap(ref arr[0], ref arr[i]); //将堆顶元素和无序区的最后一个元素交换  

                MaxHeaping(arr, 0, i); //将新的无序区调整为堆  

            }

        }

 

        /// <summary>  

        /// 初始化大根堆，由底向上建堆  

        /// 完全二叉树的基本性质，最底层节点是n/2，所以从arr.Length/2开始  

        /// </summary>  

        private static void BuildMaxHeap(int[] arr)

        {

            for (int i = (arr.Length / 2) - 1; i >= 0; i--)

            {

                MaxHeaping(arr, i, arr.Length);

            }

        }

 

 

        /// <summary>  

        /// 将指定的节点调整为堆  

        /// </summary>  

        /// <param name="i">需要调整的节点</param>  

        /// <param name="heapSize">堆的大小，也指数组中无序区的长度</param>  

        private static void MaxHeaping(int[] arr, int i, int heapSize)

        {

            int left = 2 * i + 1; // 左子节点  

            int right = 2 * i + 2; // 右子节点  

            int large = i; // 临时变量，存放大的节点值  

 

            // 比较左子节点  

            if (left < heapSize && arr[left] > arr[large])

            {

                large = left;

            }

 

            // 比较右子节点  

            if (right < heapSize && arr[right] > arr[large])

            {

                large = right;

            }

 

            // 如有子节点大于自身就交换，使大的元素上移  

            if (i != large)

            {

                Swap(ref arr[i], ref arr[large]);

                MaxHeaping(arr, large, heapSize);

            }

        }

 

        //===============测试排序==================

        static void Main(string[] args)

         {

            //归并排序

             Console.WriteLine("归并排序");

            int[] array1 = {10,9,8,7,4,5,6,3,2,1,11};

            Sort.MergeSort(array1,0,array1.Length-1);

            for (int i = 0; i < array1.Length; i++)

                Console.Write(array1[i] + " ");

            Console.WriteLine();

 

            //希尔排序

            Console.WriteLine("希尔排序");

            int[] array2 = { 10, 9, 8, 7, 4, 5, 6, 3, 2, 1, 11 };

            Sort.ShellSort(array2);

            for (int i = 0; i < array2.Length; i++)

                Console.Write(array2[i] + " ");

            Console.WriteLine();

 

            //基数排序

            Console.WriteLine("基数排序");

            int[] array3 = { 10, 9, 8, 7, 4, 5, 6, 3, 2, 1, 11 };

            Sort.RadixSort(array3);

            for (int i = 0; i < array3.Length; i++)

                Console.Write(array3[i] + " ");

            Console.WriteLine();

 

            //快速排序

            Console.WriteLine("快速排序");

            int[] array4 = { 10, 9, 8, 7, 4, 5, 6, 3, 2, 1, 11 };

            Sort.QuickSort(array4,0,array4.Length-1);

            for (int i = 0; i < array4.Length; i++)

                Console.Write(array4[i] + " ");

            Console.WriteLine();

 

            //堆排序

            Console.WriteLine("堆排序");

            int[] array5 = { 10, 9, 8, 7, 4, 5, 6, 3, 2, 1, 11 };

            Sort.HeapSort(array5);

            for (int i = 0; i < array5.Length; i++)

                Console.Write(array5[i] + " ");

            Console.WriteLine();

        }

    }

}