6大排序算法，c#实现

　　

using System;
using System.Text;
using System.Collections.Generic;

namespace ArithmeticPractice
{
    static class ExtendsFunction 
    {
        public static string printArray(this Array p_arr) 
        {
            StringBuilder sb = new StringBuilder("[ ");
            for(int i = 0 ; i < p_arr.Length ; i++) 
            {
                if(i != 0) 
                {
                    sb.Append(", ");
                }
                sb.Append(p_arr.GetValue(i));
            }
            sb.Append (" ]");
            return sb.ToString ();
        }
    }
    class MainClass
    {
        public static void Main (string[] args)
        {
            int[] arr = new int[]{49, 38, 65, 97, 76, 13, 27, 49};
            int[] sortedArr = null;
            while(true) 
            {
                Console.WriteLine ("请选择算法(从小到大排序)：\n0.退出 1.冒泡排序 2.选择排序 3.插入排序 4.希尔排序 5.快速排序 6.堆排序");
                string choose = Console.ReadLine ();

                Console.WriteLine("排序前：" + arr.printArray());
                switch(choose) {
                case "1":
                    sortedArr = bubbleSort(arr);
                    break;
                case "2":
                    sortedArr = chooseSort(arr);
                    break;
                case "3":
                    sortedArr = insertSort(arr);
                    break;
                case "4":
                    sortedArr = shellSort(arr);
                    break;
                case "5":
                    sortedArr = quickSort(arr);
                    break;
                case "6":
                    sortedArr = heapSort(arr);
                    break;
                default:
                    return;
                }
                Console.WriteLine("排序后：" + sortedArr.printArray());
            }
        }
        /// <summary>
        /// 冒泡排序
        /// </summary>
        /// <param name="p_arr">P_arr.</param>
        private static int[] bubbleSort(int[] p_arr) 
        {
            for(int i = p_arr.Length - 1; i > 0 ; i--)
            {
                for(int j = p_arr.Length - 1; j > p_arr.Length - i - 1 ; j--) 
                {
                    if(p_arr[j - 1] > p_arr[j] )
                    {
                        int temp = p_arr[j];
                        p_arr[j] = p_arr[j - 1];
                        p_arr[j - 1] = temp;
                    }
                }
            }
            return p_arr;
        }
        /// <summary>
        /// 选择排序
        /// </summary>
        /// <param name="p_arr">P_arr.</param>
        private static int[] chooseSort(int[] p_arr)
        {
            for(int i = 0; i < p_arr.Length ; i++) 
            {
                var l_min = p_arr[i];
                for(int j = i + 1; j < p_arr.Length; j++)
                {
                    if(l_min > p_arr[j]) 
                    {
                        l_min = p_arr[j];
                        p_arr[j] = p_arr[i];
                        p_arr[i] = l_min;
                    }
                }
            }
            return p_arr;
        }
        /// <summary>
        /// 插入排序
        /// </summary>
        /// <returns>The sort.</returns>
        /// <param name="p_arr">P_arr.</param>
        private static int[] insertSort(int[] p_arr)
        {
            List<int> list = new List<int> ();
            list.Add (p_arr [0]);
            for (int i = 1; i < p_arr.Length; i++) 
            {
                int j = 0;
                for(; j < list.Count ; j++) 
                {
                    if(p_arr[i] < list[j]) 
                    {
                        list.Insert(j, p_arr[i]);
                        break;
                    }
                }
                if(j == list.Count) 
                {
                    list.Add(p_arr[i]);
                }
            }
            return list.ToArray ();
        }
        /// <summary>
        /// 希尔排序
        /// </summary>
        /// <returns>The sort.</returns>
        /// <param name="p_arr">P_arr.</param>
        private static int[] shellSort(int[] p_arr)
        {
            int l_cache;//用来缓存符合交换条件的那一个（这里缓存小的，因为排序是从小到大）
            int l_space = p_arr.Length;// 交换的间隔，人称增量
            while(l_space > 1){
                l_space = l_space/3 + 1;// 间隔缩小，最后一定要是1，所以不能space/2+1
                for(int index = l_space; index < p_arr.Length; index++) 
                {
                    if(p_arr[index] < p_arr[index - l_space])//当前index和index-space的需要进行交换
                    {
                        l_cache = p_arr[index];//缓存最小的那个
                        int j;
                        //*进行一次必然为true的判断，把index的值设置为前面比较大的那个，然后在往前去看看间隔为space的位置的数(假定为temp)，有没有比cache的还要大的，（cache的值不变）如果有的话就设置当前位置（不是index而是j+space）设置为假定为temp，然后继续往前看
                        for(j = index - l_space; j >= 0 && l_cache < p_arr[j]; j -= l_space) 
                        {
                            p_arr[j + l_space] = p_arr[j];
                        }
                        p_arr[j + l_space] = l_cache;
                    }
                }
            }
            return p_arr;
        }
        /// <summary>
        /// 快速排序
        /// </summary>
        /// <returns>The sort.</returns>
        /// <param name="p_arr">P_arr.</param>
        private static int[] quickSort(int[] p_arr, int p_left = 0, int p_right = 0) 
        {
            int l_left = p_left;
            int l_right = p_right;
            if(l_right == 0) 
            {
                l_right = p_arr.Length - 1;
                p_right = p_arr.Length - 1;
            }
            if (l_right > 0) 
            {
                int l_middle = p_arr[ (l_left + l_right) / 2];//中值，不一定为最中间，仅仅作为一个判断依据，是最小或者最大的都无所谓
                Console.WriteLine(" l_left " + l_left + " l_right " + l_right + " l_middle " + l_middle);
                while( l_left < l_right)
                {//从左边开始检索
                    if (p_arr [l_left] >= l_middle) 
                    {//遇到了左边比中值要大的
                        while( l_right > l_left)
                        {//开始检索右边的
                            if (p_arr [l_right] < l_middle) 
                            {//遇到右边比中值要小的,交换此时左右flag的数然后左边继续
                                int l_temp = p_arr [l_right];
                                p_arr [l_right] = p_arr [l_left];
                                p_arr [l_left] = l_temp;
                                l_right--;
                                break;
                            } else 
                            {
                                l_right--;
                            }
                        }
                    }
                    l_left++;
                }
                Console.WriteLine("--- l_left " + l_left + " l_right " + l_right + " l_middle " + l_middle);
                if(p_left < l_right)
                {//此处只所以从p_left~l_right，而不是p_left~l_left，是因为上面的l_left++了，l_right--了
                    quickSort (p_arr, p_left, l_right);
                }

                if(l_left < p_right)
                {
                    quickSort (p_arr, l_left, p_right);
                }
            }
            return p_arr;
        }
        /// <summary>
        /// 堆排序.
        /// </summary>
        /// <returns>The sort.</returns>
        /// <param name="p_arr">P_arr.</param>
        private static int[] heapSort(int[] p_arr) 
        {// 要求最后结果是从小到大，所以堆顶要放最大的元素
            int l_last = p_arr.Length - 1;//从堆地元素上溯初始化堆
            int l_index = l_last;

            while(l_index > 0)
            {
                int l_parent = (l_index + 1)/2 - 1;
                if(p_arr[l_index] > p_arr[l_parent])
                { //大于父节点，交换
                    int temp = p_arr[l_index];
                    p_arr[l_index] = p_arr[l_parent];
                    p_arr[l_parent] = temp;
                    checkChild(p_arr, l_index, l_last);
                } else {
                    int l_borther = l_index % 2 == 0? l_index - 1 : l_index + 1;//当前如果是右节点，则兄弟为左，反之亦然
                    if(l_borther <= l_last && p_arr[l_borther] > p_arr[l_parent])
                    {//兄弟节点大于父节点，交换
                        int temp = p_arr[l_borther];
                        p_arr[l_borther] = p_arr[l_parent];
                        p_arr[l_parent] = temp;
                        checkChild(p_arr, l_borther, l_last);
                    } else 
                    {
                        l_index = l_parent;
                    }
                }
            }
            Console.WriteLine ("初始化堆：" + p_arr.printArray ());
            while(l_last > 0)
            {
                int temp = p_arr[l_last];
                p_arr[l_last] = p_arr[0];
                p_arr[0] = temp;
                l_last--;
                checkChild(p_arr, 0, l_last);
            }
            return p_arr;
        }

        private static void checkChild(int[] p_arr, int p_index, int p_last)
        {
            int l_index = p_index;
            while(l_index < p_last)
            {
                int l_leftIndex = 2 * l_index + 1;//l_index的左子
                int l_rightIndex = 2 * l_index + 2;//l_index的柚子
                if(l_leftIndex > p_last && l_rightIndex > p_last)
                {//末节点
                    break;
                }
                if( l_leftIndex <= p_last && p_arr[l_leftIndex]  > p_arr[l_index])
                {//左子大于父节点，交换
                    int temp = p_arr[l_index];
                    p_arr[l_index] = p_arr[l_leftIndex];
                    p_arr[l_leftIndex] = temp;
                    checkChild(p_arr, l_leftIndex, p_last);
                }
                if( l_rightIndex <= p_last && p_arr[l_rightIndex] > p_arr[l_index])
                {//右子大于父节点，交换
                    int temp = p_arr[l_index];
                    p_arr[l_index] = p_arr[l_rightIndex];
                    p_arr[l_rightIndex] = temp;
                    checkChild(p_arr, l_rightIndex, p_last);
                }
                l_index++;
            }
        }
    }
}