排序算法的c++實現——冒泡排序

冒泡排序

冒泡排序是我們大多數人接觸到的第一種排序算法，原理簡單易懂，不多解釋。說明三點：

1. 冒泡排序是穩定排序，只有當兩個元素不同時才會交換；

2. 冒泡排序是原址排序，不需要借助額外的空間;

3. 冒泡排序通常見到的都是通過循環來實現的，其實通過遞歸來實現更簡潔。

4. 冒泡排序的時間復雜度為O(N*N)

 

代碼如下所示：

/***********************************************************************
*   Copyright (C) 2019  Yinheyi. <[e-mail]>
*   
* This program is free software; you can redistribute it and/or modify it under the terms
* of the GNU General Public License as published by the Free Software Foundation; either 
* version 2 of the License, or (at your option) any later version.

*   Brief:    
*   Author: yinheyi
*   Email: [e-mail]
*   Version: 1.0
*   Created Time: 2019年05月08日 星期三 21時53分25秒
*   Modifed Time: 2019年05月08日 星期三 23時48分18秒
*   Blog: http://www.cnblogs.com/yinheyi
*   Github: https://github.com/yinheyi
*   
***********************************************************************/


// 對於冒泡排序，這肯定是大家接觸編程時第一個碰到的排序算法。
// 原理很簡單: 以從小到大排序為例，假設一個數組的長度為n, 則：
// 第一次: 從數組尾部開始向前, 兩兩元素之間進行比較， 共比較n-1次，就可以把最小元素移
// 動到數組下標為0的地方, 此時有1個排序完成, 剩余n-1個還沒有排序。
// 第二次：還是從數組尾部開始向前，兩兩元素之間進行比較， 共比較n-2次，就可以把剩余的
// 元素中最小的元素移動到數組下標為1的地方，此時有2個元素排序完成，剩余n-2還沒有排序。
// 第三次: 重復以上過程。
//
//    原始          第一次       第二次        第三次      第四次      第五次
//     3             -12          -12           -12         ...         ...
//     2              3            1             1
//     8              2            3             1
//     1              8            2             3
//    -12             1            8             2
//     32             1            1             8
//     1              32           32           32
//
//
// 說明：1. 冒泡排序是穩定排序，只有當兩個元素不同時才會交換；
//       2. 冒泡排序通常見到的都是通過循環來實現的，其實通過遞歸來實現更簡潔。 
//       3. 冒泡排序的時間復雜度為O(N*N)
//
//
bool less(int lhs, int rhs);
bool greate(int lhs, int rhs);
static inline void swap(int& lhs, int & rhs);
void PrintArray(int array[], int nLength_);
typedef bool (*Comp)(int, int);

//  基於循環來實現的冒泡排序:
void BubbleSort_Loop(int array[], int nLength_, Comp CompFunc)
{
    if (array == nullptr || nLength_ <= 1 || CompFunc == nullptr)
        return;

    // 對於n個元素，只需要排前n-1個元素即可, 即下標為0, 1, 2, ..., n-2的元素。
    for (int i = 0; i < nLength_ - 1; ++i)
    {   
        // 如果要使下標為i的元素變成有序的，需要從數組尾部開始兩兩交換，直至交換到i
        for (int j = nLength_ - 1; j > i; --j)
        {
            if (!CompFunc(array[j-1], array[j]))
            {
                swap(array[j-1], array[j]);
            }
        }
    }   
}

// 基於遞歸來實現冒泡排序：
void BubbleSort_Recursion(int array[], int nLength_, Comp CompFunc)
{
    if (array == nullptr || nLength_ <= 1 || CompFunc == nullptr)
        return;

    // 從數組尾部向前，對不符合要求的元素進行兩兩交換，從而使數組頭部的元素為最小或最大
    for (int i = nLength_ - 1; i > 0;  --i)
    {
        if (!CompFunc(array[i-1], array[i]))
        {
            swap(array[i-1], array[i]);
        }
    }

    // 對數組剩余的元素進行遞歸操作
    BubbleSort_Recursion(array + 1, nLength_ - 1, CompFunc);
}

// 小小的測試
#include <iostream>
/***************    main.c     *********************/
int main(int argc, char* argv[])
{
    int test1[10] = {-1, -23, 33, 423, -2349, 1, 1, 0, 9, 10};
    std::cout << "原順序為：" << std::endl;
    PrintArray(test1, 10);

    std::cout << "基於循環的從小到大排序：" << std::endl;
    BubbleSort_Loop(test1, 10, less);
    PrintArray(test1, 10);
    std::cout << "基於循環的從大到小排序：" << std::endl;
    BubbleSort_Loop(test1, 10, greate);
    PrintArray(test1, 10);

    std::cout << "基於遞歸的從小到大排序：" << std::endl;
    BubbleSort_Recursion(test1, 10, less);
    PrintArray(test1, 10);
    std::cout << "基於遞歸的從大到小排序：" << std::endl;
    BubbleSort_Recursion(test1, 10, greate);
    PrintArray(test1, 10);

    return 0;
}

// 小於比較函數
bool less(int lhs, int rhs)
{
    return lhs < rhs;
}

// 大於比較函數
bool greate(int lhs, int rhs)
{
    return lhs > rhs;
}

// 交換兩個元素的值
static inline void swap(int& lhs, int & rhs)
{
    int _nTemp = lhs;
    lhs = rhs;
    rhs = _nTemp;
}

// 打印數組函數
void PrintArray(int array[], int nLength_)
{
    if (nullptr == array || nLength_ <= 0)
        return;

    for (int i = 0; i < nLength_; ++i)
    {
        std::cout << array[i] << " ";
    }

    std::cout << std::endl;
}