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 =  ; i < p_arr.Length ; i++)
             {
                 if(i != )
                 {
                     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[]{, , , , , , , };
             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 "":
                     sortedArr = bubbleSort(arr);
                     break;
                 case "":
                     sortedArr = chooseSort(arr);
                     break;
                 case "":
                     sortedArr = insertSort(arr);
                     break;
                 case "":
                     sortedArr = shellSort(arr);
                     break;
                 case "":
                     sortedArr = quickSort(arr);
                     break;
                 case "":
                     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 - ; i >  ; i--)
             {
                 for(int j = p_arr.Length - ; j > p_arr.Length - i -  ; j--)
                 {
                     if(p_arr[j - ] > p_arr[j] )
                     {
                         int temp = p_arr[j];
                         p_arr[j] = p_arr[j - ];
                         p_arr[j - ] = temp;
                     }
                 }
             }
             return p_arr;
         }
         /// <summary>
         /// 选择排序
         /// </summary>
         /// <param name="p_arr">P_arr.</param>
         private static int[] chooseSort(int[] p_arr)
         {
             for(int i = ; i < p_arr.Length ; i++)
             {
                 var l_min = p_arr[i];
                 for(int j = i + ; 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 []);
             for (int i = ; i < p_arr.Length; i++)
             {
                 int j = ;
                 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 > ){
                 l_space = l_space/ + ;// 间隔缩小，最后一定要是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 >=  && 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 = , int p_right = )
         {
             int l_left = p_left;
             int l_right = p_right;
             if(l_right == )
             {
                 l_right = p_arr.Length - ;
                 p_right = p_arr.Length - ;
             }
             if (l_right > )
             {
                 int l_middle = p_arr[ (l_left + l_right) / ];//中值，不一定为最中间，仅仅作为一个判断依据，是最小或者最大的都无所谓
                 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 - ;//从堆地元素上溯初始化堆
             int l_index = l_last;

             while(l_index > )
             {
                 int l_parent = (l_index + )/ - ;
                 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 %  == ? l_index -  : l_index + ;//当前如果是右节点，则兄弟为左，反之亦然
                     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 > )
             {
                 int temp = p_arr[l_last];
                 p_arr[l_last] = p_arr[];
                 p_arr[] = temp;
                 l_last--;
                 checkChild(p_arr, , 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 =  * l_index + ;//l_index的左子
                 int l_rightIndex =  * l_index + ;//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++;
             }
         }
     }
 }