原文鏈接https://blog.csdn.net/foreverling/article/details/43798223,
感謝原文作者 楚興大牛的分享,轉載只爲了能方便閱讀,如有侵權還請聯繫,我將馬上對文章進行刪除

轉

九大排序算法總結

排序算法可以分爲內部排序和外部排序，內部排序是數據記錄在內存中進行排序，而外部排序是因排序的數據很大，一次不能容納全部的排序記錄，在排序過程中需要訪問外存。

常見的內部排序算法有：插入排序、希爾排序、選擇排序、冒泡排序、歸併排序、快速排序、堆排序、基數排序等。

算法一：插入排序

插入排序是一種最簡單直觀的排序算法，它的工作原理是通過構建有序序列，對於未排序數據，在已排序序列中從後向前掃描，找到相應位置並插入。

算法步驟

1）將第一待排序序列第一個元素看做一個有序序列，把第二個元素到最後一個元素當成是未排序序列。

2）從頭到尾依次掃描未排序序列，將掃描到的每個元素插入有序序列的適當位置。（如果待插入的元素與有序序列中的某個元素相等，則將待插入元素插入到相等元素的後面。）

實現代碼

void insert_sort(int *num, int len)
{
    for (int i = 1; i < len; i++)
    {
        int temp = num[i];
        int j = i;
        while (j > 0 && num[j - 1] > temp)
        {
            num[j] = num[j - 1];
            j--;
        }
        num[j] = temp;
    }
}

算法二：希爾排序

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

希爾排序是基於插入排序的以下兩點性質而提出改進方法的：

插入排序在對幾乎已經排好序的數據操作時，效率高，即可以達到線性排序的效率
但插入排序一般來說是低效的，因爲插入排序每次只能將數據移動一位

希爾排序的基本思想是：先將整個待排序的記錄序列分割成爲若干子序列分別進行直接插入排序，待整個序列中的記錄“基本有序”時，再對全體記錄進行依次直接插入排序。

算法步驟

1）選擇一個增量序列t1，t2，…，tk，其中ti>tj，tk=1；

2）按增量序列個數k，對序列進行k 趟排序；

3）每趟排序，根據對應的增量ti，將待排序列分割成若干長度爲m的子序列，分別對各子表進行直接插入排序。僅增量因子爲1 時，整個序列作爲一個表來處理，表長度即爲整個序列的長度。

實現代碼1

void shell_sort(int num[], int len)
{
    int i, j, k, group, temp;
    for (group = len / 2; group > 0; group /= 2)
    {
        //對每個分組進行插入排序
        for (i = 0; i < group; i++)
        {
            for (j = i + group; j < len; j += group)
            {
                if (num[j - group] > num[j])
                {
                    temp = num[j];
                    k = j - group;
                    while(k >= 0 && num[k] > temp)
                    {
                        num[k + group] = num[k];
                        k -= group;
                    }
                    num[k + group] = temp;
                }
            }
        }
    }
}

實現代碼2

void shell_sort(int *num, int len)
{
    for (int d = len / 2; d > 0; d /= 2)
    {
        //每個元素與其組內的元素進行插入排序
        for (int i = d; i < len; i++)
        {
            int temp = num[i];
            int j = i;
            while (j >= d && num[j - d] > temp)
            {
                num[j] = num[j - d];
                j -= d;
            }
            num[j] = temp;
        }
    }
}

兩種實現方式的區別在於是否以組爲單位進行處理，第一種實現方式以組爲單位進行處理，處理完第1組再繼續處理第二組，……，而第二種方式是將其中一組中的一個元素與其組內元素進行插入排序，然後對另一分組中的一個元素進行上述操作，……。

算法三：選擇排序

選擇排序(Selection sort)也是一種簡單直觀的排序算法。

算法步驟

1）首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置

2）再從剩餘未排序元素中繼續尋找最小（大）元素，然後放到已排序序列的末尾。

3）重複第二步，直到所有元素均排序完畢。

實現代碼

void selection_sort(int num[], int len)
{
    for (int i = 0; i < len - 1; i ++)
    {
        int j = i;
        for (int k = i + 1; k < len; k++)
        {
            if (num[k] < num[j])
            {
                j = k;
            }
        }

        if (j != i)
        {
            int temp = num[j];
            num[j] = num[i];
            num[i] = temp;
        }
    }
}

算法四：冒泡排序

冒泡排序（Bubble sort）也是一種簡單直觀的排序算法。它重複地走訪過要排序的數列，一次比較兩個元素，如果他們的順序錯誤就把他們交換過來。走訪數列的工作是重複地進行直到沒有再需要交換，也就是說該數列已經排序完成。這個算法的名字由來是因爲越小的元素會經由交換慢慢“浮”到數列的頂端。

算法步驟

1）比較相鄰的元素。如果第一個比第二個大，就交換他們兩個。

2）對每一對相鄰元素作同樣的工作，從開始第一對到結尾的最後一對。這步做完後，最後的元素會是最大的數。

3）針對所有的元素重複以上的步驟，除了最後一個。

4）持續每次對越來越少的元素重複上面的步驟，直到沒有任何一對數字需要比較。

實現代碼

void bubble_sort(int num[], int len)
{
    bool exchange;
    for (int i = 0; i < len - 1; i++)
    {
       exchange = false;
       for (int j = 0; j < len - i - 1; j++)
       {
           if (num[j] > num[j + 1])
           {
               int temp = num[j];
               num[j] = num[j + 1];
               num[j + 1] = temp;
               exchange = true;
           }
       }
       if (!exchange)
       {
           return;
       }
    }
}

算法五：歸併排序

歸併排序（Merge sort）是建立在歸併操作上的一種有效的排序算法。該算法是採用分治法（Divide and Conquer）的一個非常典型的應用。

算法步驟

申請空間，使其大小爲兩個已經排序序列之和，該空間用來存放合併後的序列
設定兩個指針，最初位置分別爲兩個已經排序序列的起始位置
比較兩個指針所指向的元素，選擇相對小的元素放入到合併空間，並移動指針到下一位置
重複步驟3直到某一指針達到序列尾
將另一序列剩下的所有元素直接複製到合併序列尾

實現代碼

//first和end爲num第一個元素和最後一個元素的索引
void merge_sort(int num[], int first, int end)
{
    if (first < end)
    {
        int mid = (first + end) / 2;
        merge_sort(num, first, mid);
        merge_sort(num, mid + 1, end);
        merge(num, first, mid, end);
    }
}

//合併序列[start, mid]、[mid+1, end]
void merge(int num[], int first, int mid, int end)
{
    int n1 = mid - first + 1;
    int n2 = end - mid;
    int* L = new int[n1];
    int* R = new int[n2];
    for(int i = 0; i < n1; i++)
    {
        L[i] = num[first + i];
    }

    for (int j = 0; j < n2; j++)
    {
        R[j] = num[mid + j + 1];
    }

    int i = 0;
    int j = 0;
    int k = first;
    while(i < n1 && j < n2)
    {
        if (L[i] < R[j])
        {
            num[k++] = L[i++];
        }
        else
        {
            num[k++] = R[j++];
        }
    }

    while (i < n1)
    {
        num[k++] = L[i++];
    }

    while (j < n2)
    {
        num[k++] = R[j++];
    }

    delete [] L;
    delete [] R;
}

算法六：快速排序

快速排序是由東尼·霍爾所發展的一種排序算法。在平均狀況下，排序 n 個項目要Ο(n log n)次比較。在最壞狀況下則需要Ο(n2)次比較，但這種狀況並不常見。事實上，快速排序通常明顯比其他Ο(n log n) 算法更快，因爲它的內部循環（inner loop）可以在大部分的架構上很有效率地被實現出來。

快速排序使用分治法（Divide and conquer）策略來把一個串行（list）分爲兩個子串行（sub-lists）。

算法步驟

1 從數列中挑出一個元素，稱爲 “基準”（pivot），

2 重新排序數列，所有元素比基準值小的擺放在基準前面，所有元素比基準值大的擺在基準的後面（相同的數可以到任一邊）。在這個分區退出之後，該基準就處於數列的中間位置。這個稱爲分區（partition）操作。

3 遞歸地（recursive）把小於基準值元素的子數列和大於基準值元素的子數列排序。

遞歸的最底部情形，是數列的大小是零或一，也就是永遠都已經被排序好了。雖然一直遞歸下去，但是這個算法總會退出，因爲在每次的迭代（iteration）中，它至少會把一個元素擺到它最後的位置去。

實現代碼1

int partition(int num[], int left, int right)
{
    int x = num[right];
    int i = left;
    int j = left - 1;
    for (; i < right; i++)
    {
        if (num[i] < x)
        {
            j++;
            if (j != i)
            {
                swap(num[j], num[i]);
            }
        }
    }
    swap(num[j + 1], num[right]);

    return j + 1;  //返回分割點
}

void quick_sort(int num[], int left, int right)
{
    if (left < right)
    {
        int index = partition(num, left, right);
        quick_sort(num, left, index - 1);
        quick_sort(num, index + 1, right);
    }
}

實現代碼2

void quick_sort(int num[], int left, int right)
{
    if (left < right)
    {
        int i = left;
        int j = right;
        int x = num[i];
        while (i < j)
        {
            while (i < j && num[j] >= x)
            {
                j--;
            }
            if(i < j)
            {
                num[i++] = num[j];
            }

            while (i < j && num[i] < x)
            {
                i++;
            }
            if(i < j)
            {
                num[j--] = num[i];
            }
        }
        num[i] = x;

        quick_sort(num, left, i - 1);
        quick_sort(num, i + 1, right);
    }
}

實現代碼1以最右邊的點爲基準，實現代碼2以最左邊的點爲基準。

算法七：堆排序

堆排序（Heapsort）是指利用堆這種數據結構所設計的一種排序算法。堆積是一個近似完全二叉樹的結構，並同時滿足堆積的性質：即子結點的鍵值或索引總是小於（或者大於）它的父節點。

堆排序的平均時間複雜度爲Ο(nlogn) 。

算法步驟

1）創建一個堆H[0..n-1]

2）把堆首（最大值）和堆尾互換

3）把堆的尺寸縮小1，並調用shift_down(0),目的是把新的數組頂端數據調整到相應位置

4）重複步驟2，直到堆的尺寸爲1

實現代碼

void heap_build(int num[], int root, int len)
{
    int lchild = root * 2 + 1;
    if (lchild < len)
    {
        int largest = lchild;
        int rchild = lchild + 1;
        if (rchild < len)
        {
            if (num[rchild] > num[largest])
            {
                largest = rchild;
            }
        }
        if (num[root] < num[largest])
        {
            swap(num[root], num[largest]);
            heap_build(num, largest, len);
        }
    }
}

void heap_sort(int num[], int len)
{
    for (int i = len / 2; i >= 0; i--)
    {
        heap_build(num, i, len);
    }

    for (int j = len - 1; j >= 1; j--)
    {
        swap(num[0], num[j]);
        heap_build(num, 0, --len);
    }
}

算法八：基數排序

基數排序是一種非比較型整數排序算法，其原理是將整數按位數切割成不同的數字，然後按每個位數分別比較。由於整數也可以表達字符串（比如名字或日期）和特定格式的浮點數，所以基數排序也不是隻能使用於整數。

說基數排序之前，我們簡單介紹桶排序：

算法思想：是將陣列分到有限數量的桶子裏。每個桶子再個別排序（有可能再使用別的排序算法或是以遞迴方式繼續使用桶排序進行排序）。桶排序是鴿巢排序的一種歸納結果。當要被排序的陣列內的數值是均勻分配的時候，桶排序使用線性時間（Θ（n））。但桶排序並不是比較排序，他不受到 O(n log n) 下限的影響。
簡單來說，就是把數據分組，放在一個個的桶中，然後對每個桶裏面的在進行排序。

例如要對大小爲[1..1000]範圍內的n個整數A[1..n]排序

首先，可以把桶設爲大小爲10的範圍，具體而言，設集合B[1]存儲[1..10]的整數，集合B[2]存儲 (10..20]的整數，……集合B[i]存儲( (i-1)*10, i*10]的整數，i = 1,2,..100。總共有 100個桶。

然後，對A[1..n]從頭到尾掃描一遍，把每個A[i]放入對應的桶B[j]中。再對這100個桶中每個桶裏的數字排序，這時可用冒泡，選擇，乃至快排，一般來說任何排序法都可以。

最後，依次輸出每個桶裏面的數字，且每個桶中的數字從小到大輸出，這樣就得到所有數字排好序的一個序列了。

假設有n個數字，有m個桶，如果數字是平均分佈的，則每個桶裏面平均有n/m個數字。如果對每個桶中的數字採用快速排序，那麼整個算法的複雜度是

O(n + m * n/m*log(n/m)) = O(n + nlogn – nlogm)

從上式看出，當m接近n的時候，桶排序複雜度接近O(n)

當然，以上複雜度的計算是基於輸入的n個數字是平均分佈這個假設的。這個假設是很強的，實際應用中效果並沒有這麼好。如果所有的數字都落在同一個桶中，那就退化成一般的排序了。

前面說的幾大排序算法，大部分時間複雜度都是O（n2），也有部分排序算法時間複雜度是O(nlogn)。而桶式排序卻能實現O（n）的時間複雜度。但桶排序的缺點是：

1）首先是空間複雜度比較高，需要的額外開銷大。排序有兩個數組的空間開銷，一個存放待排序數組，一個就是所謂的桶，比如待排序值是從0到m-1，那就需要m個桶，這個桶數組就要至少m個空間。

2）其次待排序的元素都要在一定的範圍內等等。

實現代碼

//獲取最大位數
int max_bit(int num[], int len)
{
    int bit = 1;
    int radix = 10;
    for (int i = 0; i < len; i++)
    {
        while (num[i] >= radix)
        {
            radix *= 10;
            bit++;
        }
    }

    return bit;
}

void radix_sort(int num[], int len)
{
    int bitCount = max_bit(num, len);
    int *tmp = new int[len];
    int *count = new int[10];  //計數器

    int radix = 1;
    int i, j, k;
    for(i = 0; i < bitCount; i++)  //進行bitCount次排序
    {
        for(j = 0; j < 10; j++)
        {
            count[j] = 0;
        }

        for(j = 0; j < len; j++)  //統計每個桶中的記錄數
        {
            k = (num[j] / radix) % 10;
            count[k]++;
        }

        for (j = 1; j < 10; j++)  //將tmp中的位置一次分配給每個桶
        {
            count[j] = count[j] + count[j - 1];
        }

        for (j = len - 1; j >= 0; j--)  //將所有桶中記錄收集到tmp中
        {
            k = (num[j] / radix) % 10;
            tmp[count[k] - 1] = num[j];
            count[k]--;
        }

        for (j = 0; j < len; j++)  //複製臨時數組的內容到data
        {
            num[j] = tmp[j];
        }

        radix *= 10;
    }
    delete [] tmp;
    delete [] count;
}

算法九：計數排序

個人認爲計數排序侷限性比較大，但還是把它一起總結一下。

算法思想

假定輸入是有一個小範圍內的整數構成的（比如年齡等），利用額外的數組去記錄元素應該排列的位置，思想比較簡單。
特點：在一定限制下時間複雜度爲O(n)，額外空間O(n)（需要兩個數組），穩定排序！

實現代碼

//假定數組中元素的取值範圍是[0,k]，因此需分配k+1個內存空間
void counting_sort(int num[], int len, int k)
{
    int *count = new int[k + 1];
    int *tmp = new int[len];
    for (int i = 0; i < k; i++)
    {
        count[i] = 0;
    }
    for (int i = 0; i < len; i++)
    {
        count[num[i]]++;
    }
    for (int i = 1; i < k; i++)
    {
        count[i] += count[i - 1];
    }

    int index;
    for (int i = 0; i < len; i++)
    {
        index = count[num[i]];
        tmp[index - 1] = num[i];
        count[num[i]]--;
    }

    for (int i = 0; i < len; i++)
    {
        num[i] = tmp[i];
    }
}

總結

各種排序的穩定性，時間複雜度、空間複雜度、穩定性總結如下圖：

轉載請註明出處：
http://blog.csdn.net/foreverling/article/details/43798223
http://www.cricode.com/3212.html

九大排序算法總結(冒泡,插入,快速,選擇,歸併等java實現)(轉) 九大排序算法總結

九大排序算法總結

算法一：插入排序

算法步驟

實現代碼

算法二：希爾排序

算法步驟

實現代碼1

實現代碼2

算法三：選擇排序

算法步驟

實現代碼

算法四：冒泡排序

算法步驟

實現代碼

算法五：歸併排序

算法步驟

實現代碼

算法六：快速排序

算法步驟

實現代碼1

實現代碼2

算法七：堆排序

算法步驟

實現代碼

算法八：基數排序

實現代碼

算法九：計數排序

算法思想

實現代碼

總結

DJango視圖(views)和模版(templates)的使用

進程之間使用隊列Queue()通信

簡單的總結一下到底什麼是python

DJango模型,字段,元選項,管理器.

python中生成器和迭代器以及可迭代對象的區別

Mac下配置sublime實現LaTeX

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結