C#排序算法小結

前言

算法這個東西其實在開發中不多用到，特別是web開發中，可是算法也很重要，由於任何的程序，任何的軟件，都是由不少的算法和數據結構組成的。可是這不意味着算法對於每一個軟件設計人員的實際工做都是很重要的。每一個項目特色和需求特殊也致使算法運用場景上不一樣。可是我的以爲算法運用的好的話會給本身在程序設計的時候提供比較好的思路。下面就對一些排序算法小結一下，就當作本身的一個筆記吧。

插入排序

 1.簡介

插入排序（Insertion Sort）的算法描述是一種簡單直觀的排序算法。它的工做原理是經過構建有序序列，對於未排序數據，在已排序序列中從後向前掃描，找到相應位置並插入。插入排序在實現上，一般採用in-place排序（即只需用到O(1)的額外空間的排序），於是在從後向前掃描過程當中，須要反覆把已排序元素逐步向後挪位，爲最新元素提供插入空間。

2.算法描述

通常來講，插入排序都採用in-place在數組上實現。具體算法描述以下：
1.從第一個元素開始，該元素能夠認爲已經被排序
2.取出下一個元素，在已經排序的元素序列中從後向前掃描
3.若是該元素（已排序）大於新元素，將該元素移到下一位置
4.重複步驟3，直到找到已排序的元素小於或者等於新元素的位置
5.將新元素插入到該位置後
6.重複步驟2~5
若是比較操做的代價比交換操做大的話，能夠採用二分查找法來減小比較操做的數目。該算法能夠認爲是插入排序的一個變種，稱爲二分查找排序。

3.使用插入排序爲一列數字進行排序的過程 

 

 

最差時間複雜度

最優時間複雜度

平均時間複雜度

4.C#實現

        /// <summary>
        /// 插入排序
        /// </summary>
        public class InsertionSorter
        {
            public void Sort(int[] list)
            {
                for (int i = 1; i < list.Length; ++i)
                {
                    int t = list[i];
                    int j = i;
                    while ((j > 0) && (list[j - 1] > t))
                    {
                        list[j] = list[j - 1];
                        --j;
                    }
                    list[j] = t;
                }

            }
        }

數組

int[] iArrary = new int[] { 1, 5, 3, 6, 10, 55, 9, 2, 87, 12, 34, 75, 33, 47 };

 

希爾排序

 1.簡介

希爾排序，也稱遞減增量排序算法，是插入排序的一種更高效的改進版本。希爾排序是非穩定排序算法。

2.算法實現

原始的算法實如今最壞的狀況下須要進行O(n2)的比較和交換。V. Pratt的書[1] 對算法進行了少許修改，可使得性能提高至O(n log2 n)。這比最好的比較算法的O(n log n)要差一些。
希爾排序經過將比較的所有元素分爲幾個區域來提高插入排序的性能。這樣可讓一個元素能夠一次性地朝最終位置前進一大步。而後算法再取愈來愈小的步長進行排序，算法的最後一步就是普通的插入排序，可是到了這步，需排序的數據幾乎是已排好的了（此時插入排序較快）。
假設有一個很小的數據在一個已按升序排好序的數組的末端。若是用複雜度爲O(n2)的排序（冒泡排序或插入排序），可能會進行n次的比較和交換才能將該數據移至正確位置。而希爾排序會用較大的步長移動數據，因此小數據只需進行少數比較和交換便可到正確位置。
一個更好理解的希爾排序實現：將數組列在一個表中並對列排序（用插入排序）。重複這過程，不過每次用更長的列來進行。最後整個表就只有一列了。將數組轉換至表是爲了更好地理解這算法，算法自己僅僅對原數組進行排序（經過增長索引的步長，例如是用i += step_size而不是i++）。

3.排序過程

 

最差時間複雜度 根據步長串行的不一樣而不一樣。

最優時間複雜度 O(n)

平均時間複雜度  根據步長串行的不一樣而不一樣。

4.C#實現

 

        /// <summary>
        /// 希爾排序
        /// </summary>
        public class ShellSorter
        {
            public void Sort(int[] list)
            {
                int inc;
                for (inc = 1; inc <= list.Length / 9; inc = 3 * inc + 1) ;
                for (; inc > 0; inc /= 3)
                {
                    for (int i = inc + 1; i <= list.Length; i += inc)
                    {
                        int t = list[i - 1];
                        int j = i;
                        while ((j > inc) && (list[j - inc - 1] > t))
                        {
                            list[j - 1] = list[j - inc - 1];
                            j -= inc;
                        }
                        list[j - 1] = t;
                    }
                }
            }
        }

 

選擇排序

 1.簡介

選擇排序(Selection sort)是一種簡單直觀的排序算法。它的工做原理以下。首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，而後，再從剩餘未排序元素中繼續尋找最小（大）元素，而後放到已排序序列的末尾。以此類推，直到全部元素均排序完畢。
選擇排序的主要優勢與數據移動有關。若是某個元素位於正確的最終位置上，則它不會被移動。選擇排序每次交換一對元素，它們當中至少有一個將被移到其最終位置上，所以對n個元素的表進行排序總共進行至多n-1次交換。在全部的徹底依靠交換去移動元素的排序方法中，選擇排序屬於很是好的一種。

2.實現過程

 

最差時間複雜度 О(n²)

最優時間複雜度 О(n²)

平均時間複雜度 О(n²)

3.C#實現

        /// <summary>
        /// 選擇排序
        /// </summary>
        public class SelectionSorter
        {
            // public enum comp {COMP_LESS,COMP_EQUAL,COMP_GRTR};
            private int min;
            // private int m=0;
            public void Sort(int[] list)
            {
                for (int i = 0; i < list.Length - 1; ++i)
                {
                    min = i;
                    for (int j = i + 1; j < list.Length; ++j)
                    {
                        if (list[j] < list[min])
                            min = j;
                    }
                    int t = list[min];
                    list[min] = list[i];
                    list[i] = t;
                    // Console.WriteLine("{0}",list[i]);
                }

            }
        }

冒泡排序

 1.簡介

冒泡排序（Bubble Sort，臺灣譯爲：泡沫排序或氣泡排序）是一種簡單的排序算法。它重複地走訪過要排序的數列，一次比較兩個元素，若是他們的順序錯誤就把他們交換過來。走訪數列的工做是重複地進行直到沒有再須要交換，也就是說該數列已經排序完成。這個算法的名字由來是由於越小的元素會經由交換慢慢「浮」到數列的頂端。
冒泡排序對n個項目須要O(n^{2})的比較次數，且能夠原地排序。儘管這個算法是最簡單瞭解和實做的排序算法之一，但它對於少數元素以外的數列排序是很沒有效率的。
冒泡排序是與插入排序擁有相等的執行時間，可是兩種法在須要的交換次數卻很大地不一樣。在最壞的狀況，冒泡排序須要O(n^{2})次交換，而插入排序只要最多O(n)交換。冒泡排序的實現（相似下面）一般會對已經排序好的數列拙劣地執行（O(n^{2})），而插入排序在這個例子只須要O(n)個運算。所以不少現代的算法教科書避免使用冒泡排序，而用插入排序取代之。冒泡排序若是能在內部循環第一次執行時，使用一個旗標來表示有無須要交換的可能，也有可能把最好的複雜度下降到O(n)。在這個狀況，在已經排序好的數列就無交換的須要。若在每次走訪數列時，把走訪順序和比較大小反過來，也能夠稍微地改進效率。有時候稱爲往返排序，由於算法會從數列的一端到另外一端之間穿梭往返。

2.算法實現
1.比較相鄰的元素。若是第一個比第二個大，就交換他們兩個。
2.對每一對相鄰元素做一樣的工做，從開始第一對到結尾的最後一對。在這一點，最後的元素應該會是最大的數。
3.針對全部的元素重複以上的步驟，除了最後一個。
4.持續每次對愈來愈少的元素重複上面的步驟，直到沒有任何一對數字須要比較。 

3.實現過程

 

最差時間複雜度

最優時間複雜度

平均時間複雜度

4.C#實現

       /// <summary>
        /// 冒泡排序
        /// </summary>
        public class bubblesort
        {
            public void BubbleSort(int[] R)
            {
                int i, j, temp; //交換標誌 
                bool exchange;
                for (i = 0; i < R.Length; i++) //最多作R.Length-1趟排序 
                {
                    exchange = false; //本趟排序開始前，交換標誌應爲假
                    for (j = R.Length - 2; j >= i; j--)
                    {
                        if (R[j + 1] < R[j])　//交換條件
                        {
                            temp = R[j + 1];
                            R[j + 1] = R[j];
                            R[j] = temp;
                            exchange = true; //發生了交換，故將交換標誌置爲真 
                        }
                    }
                    if (!exchange) //本趟排序未發生交換，提早終止算法 
                    {
                        break;
                    }
                }
            }
        }