C++|關於各種排序的總結

排序算法應該是所有學習編程語言的新手第一個接觸到的算法，本文主要介紹這些排序方法在C++中如何實現。

排序算法主要有：

1. 選擇排序
2. 冒泡排序
3. 插入排序
4. 快速排序
5. 希爾排序
6. 桶排序

以下逐一介紹這些排序方法。

1.選擇排序

這種排序方式比較容易理解，利用循環，每次找一個元素放在它最終的位置上，比如先找到最小的元素，放在首位，然后再剩下的元素中找到最小的，依此類推，最終從小到大排好。

#include <iostream>
#include <cstdlib>
#include <algorithm>
using namespace std;

int main()
{
    int n, a[10001], k;
    cin >> n;
    for (int i = 0; i < n; i++)
    {
        cin >> a[i];    //輸入數據
    }

    for (int i = 0; i < n; i++)
    {
        k = i;  //  設置這一次確定哪一位
        for (int j = i; j < n; j++) //嵌套一個循環，找到最小的那一個
        {
            if (a[j] < a[k])
            {
                k = j;
            }
        }

        swap(a[i], a[k]);   //把這次循環最小的（需要的）搞到前面來，也就是搞到它應該在的位置
    }

    for (int i = 0; i < n; i++)
    {
        cout << a[i] << ' ';    //輸出數據
    }
    cout << endl;

    system("pause");
    return 0;
}

 2.冒泡排序

這是另一種常見的排序方式，通過對違反順序的相鄰元素進行調整以達成目標，假設需要從小到大進行排序，那么每次循環都會從頭開始比較相鄰兩個元素的大小，小的放在前面，大的放在后面，一輪結束后，最大的元素（泡）便被“冒”到了最后。每次循環都是如此。

在循環中可以加一個終止條件：如果一輪下來后沒有過調整次序，那么說明已經排序完畢，跳出循環即可。

#include <iostream>
#include <cstdlib>
#include <algorithm>
using namespace std;

int main()
{
    int n, a[10001];
    bool flag;  //用於記錄一次循環中有沒有發生過元素交換

    cin >> n;
    for (int i = 0; i < n; i++)
    {
        cin >> a[i];    //輸入數據
    }

    for (int i = 1; i < n; i++)     //注意這個循環只有(n-1)次
    {
        flag = false;   //一開始先設置flag為false
        for (int j = 0 ; j < n - i; j++)
        {
            if (a[j] > a[j + 1])
            {
                swap(a[j], a[j + 1]);   //相鄰的進行比較，並調整
                flag = true;
            }
        }
        //cout << a[i] << ' ';
        if (!flag)  //若無調整，則跳出循環
            break;
    }

    for (int i = 0; i < n; i++)
    {
        cout << a[i] << ' ';    //輸出數據
    }
    cout << endl;
    system("pause");
    return 0;
}

3.插入排序（直接插入排序）

插入排序，顧名思義，是將新的元素插入到原來已經排列好的一組數中。在具體實現時，可以將數組分為兩部分。第一部分是除最后一位的其它所有元素，並且給出一個空間，使得可以讓第二部分中的待插入元素有位置；第二部分是待插入的元素。第一部分排完序后，操作第二部分。

原理流程如下動圖所示（侵刪）：

雖然插入排序和選擇排序的時間復雜度一樣，但是插入排序的第二重循環可以提前結束，不需要遍歷到開始位置。尤其是對於已經快要排列好的數組。

#include <iostream>
#include <cstdlib>
#include <algorithm>
using namespace std;

void insertSelectionSort(int arr[], int n)  //這種排序不需要用swap交換語句，只需要復制即可
{
    for (int i = 1; i < n; i++)     //插入排序在進行時不需要考慮第一個數的情況，一個數，必然有序
    {
        int key = arr[i];   //取出待排序的數
        int j;
        for (j = i; j > 0 && arr[j - 1] > key; j--)     //有兩個限制條件，第二個限制條件使得插入排序比選擇排序高效
            arr[j] = arr[j - 1];
        
        arr[j] = key;
    }
}

int main()
{
    int n, a[10001];

    cin >> n;
    for (int i = 0; i < n; i++)
    {
        cin >> a[i];    //輸入數據
    }

    insertSelectionSort(a, n);

    for (int i = 0; i < n; i++)
    {
        cout << a[i] << ' ';    //輸出數據
    }
    cout << endl;

    system("pause");
    return 0;
}

4.快速排序

快速排序是一種相當高效的算法，主要采用的分治的思想方法。一次排序過后，確立一個樞軸，放在某個位置，讓左邊的數都小於它，右邊的數都大於它。

主要是搞清一輪探測到底要達成什么目的，上下的只需要遞歸即可。

取一左一右向中間慢慢移動，一旦發現有前大於后，就交換，知道兩者相碰，設置第一個數作為樞軸，開始遞歸。

#include <iostream>
#include <cstdlib>
#include <algorithm>
using namespace std;

void quickSort(int left, int right, int arr[])
{
    if(left >= right)
        return;
    
    int i, j, base;
    i = left, j = right;
    base = arr[left];  //取最左邊的數為基准數
    while (i < j)
    {
        while (arr[j] >= base && i < j)
            j--;
        while (arr[i] <= base && i < j)
            i++;
        if(i < j)
            swap(arr[i], arr[j]);
    }

    //基准數歸位
    arr[left] = arr[i];
    arr[i] = base;

    //一輪基本探測已結束

    quickSort(left, i - 1, arr);    //遞歸左邊
    quickSort(i + 1, right, arr);   //遞歸右邊
}

int main()
{
    int n, a[10001];

    cin >> n;
    for (int i = 0; i < n; i++)
    {
        cin >> a[i];    //輸入數據
    }

    quickSort(0, n - 1, a);

    for (int i = 0; i < n; i++)
    {
        cout << a[i] << ' ';    //輸出數據
    }
    cout << endl;

    system("pause");
    return 0;
}

5.希爾排序

希爾排序是在不相鄰的元素之間進行交換等操作。

關鍵是增量gap的設置，每次一輪下來之后，gap都要相應地減小，本文給出的例子是變為原來的1/2。對於每一輪，內部都是用插入排序。直到gap最后一次是1時插入排序完，便得到了最終的結果。

#include <iostream>
#include <cstdlib>
#include <algorithm>
using namespace std;

const int Dgap = 2;

void shellSort(int arr[], int len)
{
    int insertNumber = 0;
    int gap = len / Dgap;    //必須保證此時gap不小於1，否則無法進入while循環
    while (gap >= 1)
    {
        for (int i = gap; i < len; i++)
        {
            insertNumber = arr[i];
            int j = i;
            while (j >= gap && insertNumber < arr[j - gap])
            {
                arr[j] = arr[j - gap];
                j -= gap;
            }
            arr[j] = insertNumber;
        }
        gap /= Dgap;
    }
}

int main()
{
    int n, a[10001];

    cin >> n;
    for (int i = 0; i < n; i++)
    {
        cin >> a[i];    //輸入數據
    }

    shellSort(a, n);

    for (int i = 0; i < n; i++)
    {
        cout << a[i] << ' ';    //輸出數據
    }
    cout << endl;

    system("pause");
    return 0;
}

6.桶排序

桶排序，顧名思義，我們需要放置桶，對於簡單的例子，可以按自然數依次放置，對於難以處理的大型數據，可以考慮“加大”桶放置的種類，使得一個區間內的都可以放進來，再對其中的各個元素進行排序。

下面給出比較簡單的一種情況的思路：先找出輸入數據中最大的數N，設置N+1個桶，遍歷輸入的數組，統計各個桶里裝了多少個，最后遍歷桶，得到排好序的數組。

#include <iostream>
#include <cstdlib>
#include <algorithm>
using namespace std;

int main()
{
    int n, a[10001], bucket[10001], max = 0;

    cin >> n;
    for (int i = 0; i < n; i++)
    {
        cin >> a[i];    //輸入數據
    }

    for (int i = 0; i < n; i++)
    {
        max = (a[i] > max ? a[i] : max);    //找到最大的元素
    }

    for (int i = 0; i < n; i++)
    {
        bucket[a[i]]++;     //統計各個桶的情況
    }

    for (int i = 1; i <= max; i++)
    {
        if (bucket[i] == 0)
            continue;
        else
        {
            for (int j = 0; j < bucket[i]; j++)
                cout << i << ' ';   //輸出最后的數列
        }
        
    }
    cout << endl;

    system("pause");
    return 0;
}

 

以上便是6種常見的排序方法。