1、冒泡算法。

冒泡算法是最基础的一个排序算法，每次使用第一个值和身后相邻的值进行比较，如果是升序将大数向左边交换，降序则向右边交换。最终将大数移动到一边，最终排成一个序列：

public class Sorting
{
    public void BubbleSorting()
    {
        int[] arr = new int[10];
        Random rd = new Random(100);
        for (int i = 0; i < arr.Length; i++)
        {
            arr[i] = rd.Next(1, 100);
        }
        Console.WriteLine("Init array:");
        Print(arr);
        Console.WriteLine("Sorting:");
        for (int i = arr.Length - 1; i >= 1; i--)
        {
            for (int j = 0; j <= i - 1; j++)
            {
                if (arr[j] > arr[j + 1])
                {
                    Swap(ref arr[j], ref arr[j + 1]);
                }
            }

            Print(arr);
        }
        Console.WriteLine("Sort Result:");
        Print(arr);
    }

    void Swap(ref int a, ref int b)
    {
        var temp = a;
        a = b;
        b = temp;
    }
    void Print(int[] list)
    {
        for (int i = 0; i < list.Length; i++)
        {
            Console.Write("" + list[i]);
        } 

        Console.WriteLine();
    }
}

结果：

2、选择排序

选择排序需要两层循环来实现，外层循环控制次数，内层循环控制找到最小的值。然后将内层循环找到的最小值与外层循环本次索引对应元素进行交换，直至遍历完整个数组。

public void SelectionSort()
{
    int[] arr = InitArray(10);
    int length = 10;
    Console.WriteLine("Sorting:");
    for (int i = 0; i < length; i++)
    {
        int min = i;
        for (int j = i + 1; j < length; j++)
        {
            if (arr[min] > arr[j]) min = j;
        }
        Swap(ref arr[i], ref arr[min]);
        Print(arr);
    }
    Console.WriteLine("Sort Result:");
    Print(arr);
}

结果：

3、插入排序

插入排序有两层循环，外层循环逐个遍历数组元素，内层循环把外层循环的元素与该元素在内层循环的下一个元素进行比较，如果外层循环选择的元素小于内层循环选择的元素，那么数组元素都行右移动为内层循环元素留出位置。

public void InsertionSort()
{
    int[] arr = InitArray(10);
    int length = 10;
    Console.WriteLine("Sorting:");
    for (int i = 1; i < length; i++)
    {
        int temp = arr[i];
        int inner=i;
        while (inner > 0 && arr[inner - 1] >= temp)
        {
            arr[inner] = arr[inner - 1];
            inner--;
        }
        arr[inner] = temp;
        Print(arr);
    }
    Console.WriteLine("Sort Result:");
    Print(arr);
}

结果：

4、三种算法的效率

做一个简单的比较,这里的初始化数据在每种算法之中, 因为每个算法都包含初始化,因此不会影响到比较.

测试代码:

static void TestSorting(int size)
{    
    Sorting sort = new Sorting();
    Stopwatch watch = new Stopwatch();
    watch.Start();
    sort.BubbleAscSorting(size);
    watch.Stop();
    Console.WriteLine("BubbleAscSorting Time Milliseconds:" + watch.ElapsedMilliseconds);
    watch.Restart();
    sort.SelectionSort(size);
    watch.Stop();
    Console.WriteLine("SelectionSort Time Milliseconds:" + watch.ElapsedMilliseconds);
    watch.Restart();
    sort.InsertionSort(size);
    Console.WriteLine("InsertionSort Time Milliseconds:" + watch.ElapsedMilliseconds);
    Console.ReadKey();
}

1000个整数结果：

10000个整数结果：

100000个整数结果：

从测试结果得到下面的表格：

忽略测试环境，因为三个算法都是在同一个环境中跑的， 可以得出如下结论：

1.冒泡算法效率最低。

2.插入算法效率最高。

3.选择算法是冒泡算法的3.3倍。

4.插入算法是冒泡算法的4.7倍。

5.插入算法是选择算法的1.4陪。