三個基本排序算法執行效率比較（冒泡排序，選擇排序和插入排序）

一、冒泡算法。

冒泡算法是最基礎的一個排序算法，每次使用第一個值和身後相鄰的值進行比較，若是是升序將大數向左邊交換，降序則向右邊交換。最終將大數移動到一邊，最終排成一個序列：

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();
    }
}

結果：

二、選擇排序

選擇排序須要兩層循環來實現，外層循環控制次數，內層循環控制找到最小的值。而後將內層循環找到的最小值與外層循環本次索引對應元素進行交換，直至遍歷完整個數組。

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);
}

結果：

 

三、插入排序

插入排序有兩層循環，外層循環逐個遍歷數組元素，內層循環把外層循環的元素與該元素在內層循環的下一個元素進行比較，若是外層循環選擇的元素小於內層循環選擇的元素，那麼數組元素都行右移動爲內層循環元素留出位置。

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);
}

結果：

四、三種算法的效率

作一個簡單的比較,這裏的初始化數據在每種算法之中, 由於每一個算法都包含初始化,所以不會影響到比較.

測試代碼:

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個整數結果：

 

 

從測試結果獲得下面的表格：

	Bubble	Selection	Insertion	Bubble/Selection	Bubble/Insertion	Selection/Insertion
1000	15	4	3	3.75	5	1.333333333
10000	1342	412	283	3.257281553	4.74204947	1.455830389
100000	125212	40794	27570	3.069372947	4.541603192	1.479651795
Avg				3.358884833	4.761217554	1.422938506

忽略測試環境，由於三個算法都是在同一個環境中跑的， 能夠得出以下結論：

1.冒泡算法效率最低。

2.插入算法效率最高。

3.選擇算法是冒泡算法的3.3倍。

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

5.插入算法是選擇算法的1.4陪。