冒泡排序的C、C++实现

一、冒泡排序

冒泡排序就是重复地走访过要排序的元素列，依次比较两个相邻的元素，如果他们的顺序（如数字从大到小、首字母从A到Z）错误就把他们交换过来。走访元素的工作是重复地进行直到没有相邻元素需要交换，也就是说该元素已经排序完成。

这个算法的名字由来是因为越大的元素会经由交换慢慢“浮”到数列的顶端（升序或降序排列），就如同碳酸饮料中二氧化碳的气泡最终会上浮到顶端一样，故名“冒泡排序”。

冒泡排序算法的原理如下：

1. 比较相邻的元素。如果第一个比第二个大，就交换他们两个。
2. 对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。
3. 针对所有的元素重复以上的步骤，除了最后一个。
4. 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

二、排序过程

如需要排序的元素为 88,1,59,105,9,2,8,15,6,10 ，将需要排序的元素按照从小到大依次排序，接下来一步一步分析使用冒泡排序对这些元素进行排序的过程。

1. 排序前： 88 1 59 105 9 2 8 15 6 10
2. 经过第一轮排序 1 59 88 9 2 8 15 6 10 105
3. 经过第二轮排序 1 59 9 2 8 15 6 10 88 105
4. 经过第三轮排序 1 9 2 8 15 6 10 59 88 105
5. 经过第四轮排序 1 2 8 9 6 10 15 59 88 105
6. 经过第五轮排序 1 2 8 6 9 10 15 59 88 105
7. 经过第六轮排序 1 2 8 6 9 10 15 59 88 105

以上就是冒泡排序的整个排序过程，经过六轮排序之后所有排序已经完成。

三、程序实现

1、不设置元素位置交换标志位。

#include<iostream>
using namespace std;

const int BUFFSIZE = 10;
int Bubble_Sort(int Arr[]);
int main()
{
    int Arr[BUFFSIZE] = { 88,1,59,105,9,2,8,15,6,10 };  // 待排序元素
    Bubble_Sort(Arr) //排序
    return 0;
}

int Bubble_Sort(int Arr[])
{
    int Counts = BUFFSIZE - 1; // 排序总轮数
    for (int i = 0; i < Counts; i++)
    {
        for (int j = 0; j < Counts - i; j++) 
        {
            if (Arr[j] > Arr[j + 1])
            {
                int tmp = Arr[j + 1];
                Arr[j + 1] = Arr[j];
                Arr[j] = tmp;
            }
        }
        //每一轮排序后输出元素顺序
        for (int i = 0; i < BUFFSIZE; i++)
        {
            cout << Arr[i] << " ";
        }
        cout << endl;
    }

    return 0;
}

程序输出：

1 59 88 9 2 8 15 6 10 105
1 59 9 2 8 15 6 10 88 105
1 9 2 8 15 6 10 59 88 105
1 2 8 9 6 10 15 59 88 105
1 2 8 6 9 10 15 59 88 105
1 2 6 8 9 10 15 59 88 105  // 在第六次的时候已经排序完成
1 2 6 8 9 10 15 59 88 105
1 2 6 8 9 10 15 59 88 105
1 2 6 8 9 10 15 59 88 105

由程序输出可以看出，在第六次的时候已经排序完成，后面几次都没有元素交换，也就是说后面几次其实是无意义的。这样我们可以改进一下排序算法，设置一个元素位置交换标志位记录本次排序是否有元素位置发生变化，如果没有则认为排序已经完成，程序不需要再继续执行，改进后的程序如下。

2、改进排序算法，设置元素位置交换标志位。

#include<iostream>
using namespace std;

const int BUFFSIZE = 10;
int Bubble_Sort_r(int Arr[]);

int main()
{ 
    int Arr2[BUFFSIZE] = { 88,1,59,105,9,2,8,15,6,10 }; // 待排序元素
    Bubble_Sort_r(Arr2); // 排序  
    return 0;
}

int Bubble_Sort_r( int Arr[])
{
    bool SwapFlag = true;  // 标志位，记录每次排序是否有元素位置交换
    int Counts = BUFFSIZE - 1;
    for (int i = 0; i < Counts&&SwapFlag!=false; i++)  // 如果上次排序元素位置未改变，则排序完成。
    {
        SwapFlag = false; // 每次排序前，标志位复位
        for (int j = 0; j < Counts - i; j++)
        {
            if (Arr[j] > Arr[j + 1])
            {
                SwapFlag = true;  //发生位置交换，标志位置位
                int tmp = Arr[j + 1];
                Arr[j + 1] = Arr[j];
                Arr[j] = tmp;
            }
        }
        for (int i = 0; i < BUFFSIZE; i++)
        {
            cout << Arr[i] << " ";
        }
        cout << endl;
    }

    return 0;
}

程序输出：

1 59 88 9 2 8 15 6 10 105
1 59 9 2 8 15 6 10 88 105
1 9 2 8 15 6 10 59 88 105
1 2 8 9 6 10 15 59 88 105
1 2 8 6 9 10 15 59 88 105
1 2 6 8 9 10 15 59 88 105  // 在第六次的时候已经排序完成
1 2 6 8 9 10 15 59 88 105  // 第七次标志位没有置位，发现排序已经完成