一、氣泡排序 
氣泡排序是一種簡單的排序方法，演算法如下： 
1. 首先將所有待排序的數字放入工作列表中。 
2. 從列表的第一個數字到倒數第二個數字，逐個檢查：若某一位上的數字大於他的下一位，則將它與它的下一位交換。 
3. 重複2號步驟(倒數的數字加1。例如：第一次到倒數第二個數字，第二次到倒數第三個數字，依此類推…)，直至再也不能交換。 
程式碼實現如下：

#include <iostream>
using namespace std;
/*交換函式，作用是交換陣列中的兩個元素的位置*/
void swap(int array[],int i,int j)
{
    int
 
 tmp=array[i];
    array[i]=array[j];
    array[j]=tmp;
}
/*氣泡排序*/
void BubbleSort(int array[],int n)
{
    for(int i=0;i<n-1;i++)
    {
        for(int j=n-1;j>i;j--)
        {
            if(array[j]<array[j-1])
                swap(array,j,j-1);
        }
    }
}
int main()
{
    int array[5
 
]={3,1,2,5,4};
    BubbleSort(array,5);
    for(int i=0;i<5;i++)
        cout<<array[i]<<"  ";
    cout<<endl;
    return 0;
}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30

最差時間複雜度 O(n²) 
最優時間複雜度 O(n) 
平均時間複雜度 O(n²) 
最差空間複雜度 O(n) total, O(1) auxiliary

二、插入排序 
插入排序也是一種簡單排序方法，演算法如下： 
1. 從第一個元素開始，認為該元素已經是排好序的。 
2. 取下一個元素，在已經排好序的元素序列中從後向前掃描。 
3. 如果已經排好序的序列中元素大於新元素，則將該元素往右移動一個位置。 
4. 重複步驟3，直到已排好序的元素小於或等於新元素。 
5. 在當前位置插入新元素。 
6. 重複步驟2。 
程式碼實現如下：

#include <iostream>
using namespace std;
/*交換函式，作用是交換陣列中的兩個元素的位置*/
void swap(int array[],int i,int j)
{
    int tmp=array[i];
    array[i]=array[j];
    array[j]=tmp;
}
/*插入排序*/
void InsertSort(int array[],int n)
{
    for(int i=1;i<n;i++)
    {
        for(int j=i;j>0;j--)
        {
            if(array[j]>array[j-1])
                swap(array,j,j-1);
            else
                break;
        }
    }
}

int main()
{
    int array[5]={3,1,2,5,4};
    InsertSort(array,5);
    for(int i=0;i<5;i++)
        cout<<array[i]<<"  ";
    cout<<endl;
    return 0;
}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30
• 31
• 32
• 33

最差時間複雜度 O(n²) 
最優時間複雜度 O(n) 
平均時間複雜度 O(n²) 
最差空間複雜度 O(n) total, O(1) auxiliary

三、選擇排序 
選擇排序的思想如下： 
1. 設陣列記憶體放了n個待排數字，陣列下標從1開始，到n結束。 
2. i=1 
3. 從陣列的第i個元素開始到第n個元素，尋找最小的元素。（具體過程為:先設arr[i]為最小，逐一比較，若遇到比之小的則交換） 
4. 將上一步找到的最小元素和第i位元素交換。 
5. 如果i=n－1演算法結束，否則回到第3步 
程式碼實現如下：

#include <iostream>
using namespace std;
/*交換函式，作用是交換陣列中的兩個元素的位置*/
void swap(int array[],int i,int j)
{
    int tmp=array[i];
    array[i]=array[j];
    array[j]=tmp;
}
/*選擇排序*/
void SelectionSort(int array[],int n)
{
    for(int i=0;i<n-1;i++)
    {
        int smallest=i;
        for(int j=i+1;j<n;j++)
        {
            if(array[smallest]>array[j])
                smallest=j;
        }
        swap(array,i,smallest);
    }
}

int main()
{
    int array[5]={3,1,2,5,4};
    SelectionSort(array,5);
    for(int i=0;i<5;i++)
        cout<<array[i]<<"  ";
    cout<<endl;
    return 0;
}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30
• 31
• 32
• 33

最差時間複雜度 О(n²) 
最優時間複雜度 О(n²) 
平均時間複雜度 О(n²) 
最差空間複雜度 О(n) total, O(1) auxiliary 
以上三種排序的時間複雜度都是O(n²)。

四、快速排序 
實踐證明，快速排序是所有排序演算法中最高效的一種。它採用了分治的思想：先保證列表的前半部分都小於後半部分，然後分別對前半部分和後半部分排序，這樣整個列表就有序了。 
快速排序的基本演算法是： 
1. 從數列中挑出一個元素，稱為 “基準”（pivot），也叫作支點， 
2. 重新排序數列，所有元素比基準值小的擺放在基準前面，所有元素比基準值大的擺在基準的後面（相同的數可以到任一邊）。在這個分割之後，該基準是它的最後位置。這個稱為分割（partition）操作。 
3. 遞迴地（recursive）把小於基準值元素的子數列和大於基準值元素的子數列排序。 
遞迴的最底部情形，是數列的大小是零或一，也就是永遠都已經被排序好了。雖然一直遞迴下去，但是這個演算法總會結束，因為在每次的迭代（iteration）中，它至少會把一個元素擺到它最後的位置去。 
程式碼實現如下：

#include <iostream>
using namespace std;
/*交換函式，作用是交換陣列中的兩個元素的位置*/
void swap(int array[],int i,int j)
{
    int tmp=array[i];
    array[i]=array[j];
    array[j]=tmp;
}
/*將軸值放到陣列的適當的位置*/
int partition(int array[],int left,int right)
{
    int mid=(left+right)/2;
    int tmp=array[mid];
    swap(array,mid,right);
    int i=left;
    int j=right;
    while(1)
    {
        /*i指標向右移動，直到找到一個大於軸值的值*/
        while(1)
        {
            /*如果i與j相遇則確定軸值位置，將其返回*/
            if(i==j)
            {
                array[i]=tmp;
                return i;
            }
            if(array[i]>tmp)
            {
                array[j]=array[i];
                j--;
                break;
            }
            i++;
        }
        /*j指標向左移動，直到找到一個小於軸值的值*/
        while(1)
        {
            /*如果i與j相遇則確定軸值位置，將其返回*/
            if(i==j)
            {
                array[j]=tmp;
                return j;
            }
            if(array[j]<tmp)
            {
                array[i]=array[j];
                i++;
                break;
            }
            j--;
        }
    }
}
/*快速排序*/
void quickSort(int array[],int left,int right)
{
    if(right<=left)
        return;
    int pivot=partition(array,left,right);
    quickSort(array,left,pivot-1);
    quickSort(array,pivot+1,right);
}

int main()
{
    int array[8]={6,8,7,3,1,2,5,4};
    quickSort(array,0,7);
    for(int i=0;i<8;i++)
        cout<<array[i]<<"  ";
    cout<<endl;
    return 0;
}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 相關推薦

  九大排序演算法的手寫實現及時空複雜度分析

  一、氣泡排序  氣泡排序是一種簡單的排序方法，演算法如下：  1. 首先將所有待排序的數字放入工作列表中。  2. 從列表的第一個數字到倒數第二個數字，逐個檢查：若某一位上的數字大於他的下一位，則將它與它的下一位交換。  3. 重複2號步驟(倒數的數字加1。例

  九大排序演算法的手寫實現及時空複雜度分析 筆試面試必備

  一、氣泡排序 氣泡排序是一種簡單的排序方法，演算法如下： 1. 首先將所有待排序的數字放入工作列表中。 2. 從列表的第一個數字到倒數第二個數字，逐個檢查：若某一位上的數字大於他的下一位，則將它與它的下一位交換。 3. 重複2號步驟(倒數的數字加1。例如

  九大排序演算法-C語言實現及詳解

  概述 排序有內部排序和外部排序，內部排序是資料記錄在記憶體中進行排序，而外部排序是因排序的資料很大，一次不能容納全部的排序記錄，在排序過程中需要訪問外存。 我們這裡說說八大排序就是內部排序。     當n較大，則應採用時間複雜度為O(nlog2n)的排序方法：快

  堆排序的JAVA實現及時間複雜度分析

  堆排序是一個比較常用的排序方式，下面是其JAVA的實現： 1. 建堆 // 對輸入的陣列進行建堆的操作 private static void buildMaxHeap(int[] array, int length) { // 遍歷所有

  二分查詢法的迴圈與遞迴實現及時間複雜度分析

  設陣列為整數陣列，從小到大排序。二分法強調一定是要先排過序的。 迴圈實現二分法程式碼： #include <iostream> using namespace std; int binary_search(int *array,int low ,int hi

  九大排序演算法之插入排序（原理及實現）

  1、演算法思路：每趟將一個待排序的元素作為關鍵字，按照其關鍵字值得大小插入到已經排好的部分的適當位置上，知道插入完成。 2、演算法過程 舉個栗子（第一趟的排序過程） 原始序列：49、38、65、97、76、13、27、49 1)開始以第一個元素49為關鍵字，看成一個序列，其餘數看成另

  九大排序演算法之選擇排序（原理及實現）

  1、演算法思想：選擇排序，從頭至尾掃描序列，找出最小的一個元素，和第一個元素交換，接著從剩下的元素中繼續這種選擇和交換方式，最終得到一個有序序列。 2、演算法過程 舉個栗子（第一趟的排序過程） 原始序列：49、38、65、97、76、13、27、49 1）在進行選擇排

  C語言實現九大排序演算法

  - [C語言實現九大排序演算法](#c語言實現九大排序演算法) - [直接插入排序](#直接插入排序) - [折半插入排序](#折半插入排序) - [希爾排序](#希爾排序) - [氣泡排序](#氣泡排序) - [快速排序](#快速排序) - [直接選擇排序](

  九大排序演算法

  概述排序有內部排序和外部排序，內部排序是資料記錄在記憶體中進行排序，而外部排序是因排序的資料很大，一次不能容納全部的排序記錄，在排序過程中需要訪問外存。 當n較大，則應採用時間複雜度為O(nlog2n)的排序方法：快速排序、堆排序或歸併排序序。 快速排序：是目前基於比較的內部

  Java版-九大排序演算法

  參考：http://blog.csdn.net/hguisu/article/details/7776068 概述 排序有內部排序和外部排序，內部排序是資料記錄在記憶體中進行排序，而外部排序是因排序的資料很大，一次不能容納全部的排序記錄，在排序過程中需要訪問外存。 我們這裡說說八

  九大排序演算法小結（複雜度）

                                    九大排序演算法小結 前面分別實現了幾大排序演算法的程式碼，但並未進行解析 現在就從演算法的時間複雜度，空間複雜度進行談起 下面這幅圖是網上考培得，但很清晰，但少了一個計數排序         

  資料結構---九大排序演算法再總結

  排序：對一序列物件根據某個關鍵字進行排序； 穩定：如果a原本在b前面，而a=b，排序之後a仍然在b的前面； 不穩定：如果a原本在b的前面，而a=b，排序之後a可能會出現在b的後面； 內排序：所有排序操作都在記憶體中完成； 外排序：由於資料太大，因此把資料放在磁碟中，而排

  常見排序演算法的基本原理、程式碼實現和時間複雜度分析

    排序演算法無論是在實際應用還是在工作面試中，都扮演著十分重要的角色。最近剛好在學習演算法導論，所以在這裡對常見的一些排序演算法的基本原理、程式碼實現和時間複雜度分析做一些總結 ，也算是對自己知識的鞏固。 說明： 1.本文所有的結果均按照非降序排列； 2.本文所有的程式均用c++實現，

  二分查詢（折半查詢）演算法（原理、實現及時間複雜度）

  查詢也是有特殊情況的，比如數列本身是有序的。這個有序數列是怎麼產生的呢？有時它可能本身就是有序的，也有可能是我們通過之前所學的排序演算法得到的。 不管怎麼說，我們現在已經得到了有序數列了並需要查詢。這時二分查詢該出場了。 二分查詢（Binary Search）也叫作折半查詢。二分查詢有兩個要求，一個是數列

  分塊查詢演算法完全攻略（原理、實現及時間複雜度）

  一般對於需要查詢的待查資料元素列表來說，如果很少變化或者幾乎不變，則我們完全可以通過排序把這個列表排好序以便我們以後查詢。但是對於經常增加資料元素的列表來說，要是每次增加資料都排序的話，那真的是有點太累人了。 所以之前我們分析過，對於幾乎不變的資料列表來說，排序之後使用二分查詢是很不錯的，但是對於經常變動的

  順序查詢演算法（原理、實現及時間複雜度）

  一提到查詢，比如從一個數列中查詢第1個值為k的數，那麼我們最先想到的肯定是一個一個地找。從數列的第 1 個數開始對比，直到找到值為k的數。 順序查詢的定義為：在一個已知無序（或有序）的佇列中找出與給定的關鍵字相同的數的具體位置。其原理是讓關鍵字與佇列中的數從開始一個一個地往後逐個比較，直到找到與給定的關鍵字

  排序演算法——希爾排序的圖解、程式碼實現以及時間複雜度分析

  希爾排序(Shellsort) 希爾排序是衝破二次時間屏障的第一批演算法之一。 希爾排序通過比較相距一定間隔的元素來工作；各躺比較所用的距離隨著演算法的進行而減小，直到只比較相鄰元素的最後一趟排序為止。由於這個原因，希爾排序有時也叫做縮減增量排序。 希爾排

  11. 常見的有哪幾種排序演算法，試比較其時間複雜度，以及是否穩定，及各自使用的情形

  1、幾種常見排序演算法的時間複雜度 排序方法 平均情況 最好情況 最壞情況 直接插入排序 O(n2) O(n) O(n2) 起泡排序 O(n2) O(n) O(n2) 快速排序 O(nlog2n) O(nlog2n)

  常見排序演算法總結（實現原理，穩定度，使用場景，時間複雜度）

  快速排序是目前基於比較的內部排序中被認為是最好的方法，當待排序的關鍵字是隨機分佈時，快速排序的平均時間最短；堆排序所需的輔助空間少於快速排序，並且不會出現快速排序可能出現的最壞情況。這兩種排序都是不穩定的。若要求排序穩定，則可選用歸併排序。但本章介紹的從單個記錄起進行兩兩歸併的排序演算法並不值得提倡，通常可以

  快速排序演算法及時間複雜度分析（原地in-place分割槽版本）

  快速排序演算法一般來說是採用遞迴來實現，其最關鍵的函式是partition分割函式，其功能是將陣列劃分為兩部分，一部分小於選定的pivot，另一部分大於選定的pivot。我們將重點放在該函式上面。 partition函式總體思路是自從一邊查詢，找到小於pivot的元素，則將