冒泡排序与插入排序(C#实现）

本人应届生面试，发现被问了2次关于排序的算法。当时竟然没写出来！！！好吧，可能是用库函数多了，很久没搞算法了，在纸上写没感觉吧。

今天花了1个多小时写了下冒泡排序与插入排序(C#实现），并写了注释和小函数，力求算法分析透彻，自解释的代码。

 //优化建议：
 //1.定义<>比较器（而不是传入字符串命令让函数判断），方便指定排序顺序
 //2.凡是带有int endIndex, int insertValue参数的函数都应该做成重载，不指定则从数组开始，或直到数组末尾
 using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;

 namespace SimpleDelegate
 {
     public class ArraySort
     {
         /// <summary>
         /// 选择排序，从小到大
         /// </summary>
         /// <param name="arr">无需ref,数组为类（引用类型）自动传递指针（引用）</param>
         public static void SelectionSort(int[] arr)
         {
             //循环，将下标为0（第一个元素）...len-2（最后第二个元素）的元素与其后元素中最小的交换
             for (int i = ; i < arr.Length - ; i++)
             {
                 //获取从i至数组末尾范围内最小元素的下标
                 int minIndex = GetMinIndex(arr, i);
                 //交换，将最小元素移至i处
                 Swap(ref arr[minIndex], ref arr[i]);
             }
         }
         /// <summary>
         /// 交换变量值
         /// </summary>
         public static void Swap(ref int i,ref int j)
         {
             int tmp = i;i = j; j = tmp;
         }
         /// <summary>
         /// 找出下标beginIndex...len-1（最后一个元素）中最小的元素的下标
         /// </summary>
         /// <param name="arr">数组</param>
         /// <param name="beginIndex">起始下标</param>
         /// <returns>数组从下标i...len-1（最后一个元素）最小的元素的下标</returns>
         public static int GetMinIndex(int[] arr, int beginIndex)
         {
             int min = beginIndex;
             for (int j = beginIndex + ; j < arr.Length; j++)
             {
                 if (arr[min] > arr[j])
                     min = j;
             }
             return min;
         }

         /*********************************************************************/
         /// <summary>
         /// 插入排序，从小到大
         /// </summary>
         public static void InsertionSort(int[] arr)
         {
             for (int i = ; i < arr.Length; i++)
             {
                 int insertValue = arr[i];
                 SortInsert(arr, i, insertValue);
             }
         }
         /// <summary>
         /// 按从小到大顺序插入元素。数组范围：开始至endIndex参数
         /// </summary>
         /// <param name="arr"></param>
         /// <param name="endIndex">插入的数组结束范围</param>
         /// <param name="insertValue">插入的元素</param>
         public static void SortInsert(int[] arr, int endIndex, int insertValue)
         {
             //找出插入点的下标
             int insertIndex = ;    //假设是0
             for (insertIndex = ; insertIndex < endIndex; insertIndex++)
             {
                 if (insertValue < arr[insertIndex])
                     break;
             }
             //插入点和其后的元素后移
             NextMove(arr,insertIndex,endIndex);
             //插入元素
             arr[insertIndex] = insertValue;
         }
         /// <summary>
         /// 从后往前后移,并返回被移出的元素
         /// 从前往后后移会导致覆盖（所有元素值变为arr[begIndex]的值）
         /// </summary>
         /// <param name="arr"></param>
         /// <param name="begIndex">数组的开始索引</param>
         /// <param name="endIndex">数组的结束索引</param>
         /// <returns>被移出的元素</returns>
         public static int NextMove(int[] arr, int begIndex, int endIndex)
         {

             for (int i = endIndex; i > begIndex; i--)
             {
                 arr[i] = arr[i - ];
             }
             return arr[endIndex];
         }
     }
 }

但还可以继续抽象，也没写冒泡排序和快速排序等，未完待续。。。

以下为运行代码：

  static void Main(string[] args)
         {
             int[] arr = new int[] { , , , , , , -, , ,  };
             ArraySort.SelectionSort(arr);
             //ArraySort.InsertionSort(arr);
             foreach (var item in arr)
             {
                 Console.WriteLine(item);
             }
             Console.WriteLine("------------");
             Console.Read();
         }

希望对各位有用！！有错也请指出。