冒泡排序与插入排序(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 = 0; i < arr.Length - 1; 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 + 1; j < arr.Length; j++)
            {
                if (arr[min] > arr[j])
                    min = j;
            }
            return min;
        }

        /*********************************************************************/
        /// <summary>
        /// 插入排序，从小到大
        /// </summary>
        public static void InsertionSort(int[] arr)
        {
            for (int i = 1; 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;    //假设是0
            for (insertIndex = 0; 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 - 1];
            }
            return arr[endIndex];
        }     
    }
}

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

以下为运行代码：

 static void Main(string[] args)
        {
            int[] arr = new int[] { 0, 0, 0, 100, 20, 200, -1, 30, 1000, 90 };
            ArraySort.SelectionSort(arr);
            //ArraySort.InsertionSort(arr);
            foreach (var item in arr)
            {
                Console.WriteLine(item);
            }
            Console.WriteLine("------------");
            Console.Read();
        }

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