数据结构之排序-冒泡排序

一.冒泡排序的原理：逐个相邻元素相互比较，将最大或者最小的值冒泡（沉底）到最高位；如下图：

第一次排序的结果为：9,5,10,7,6,8,2,4,11;

第二次排序的结果为：5,9,7,6,8,2,4,10,11;

第三次排序的结果为：5,7,6,8,2,4,9,10,11;

第四次排序的结果为：5,6,7,2,4,8,9,10,11;

第五次排序的结果为：5,6,2,4,7,8,9,10,11;

第六次排序的结果为：5,2,4,6,7,8,9,10,11;

第七次排序的结果为：2,4,5,6,7,8,9,10,11;

第八次排序的结果为：2,4,5,6,7,8,9,10,11;这个第八步排序是必须的，最后还剩两个数之间的冒泡，这里正好是顺序，所以在这里显得有点多余，但是当时反序时，是必要的；

因为每一次排序都会将一个值冒泡出来，总共有n个数，当冒泡到第那个数时，还剩下最后一个数，这个数也就是这些数中的最值，所以最后一次排序也就没必要进行；即n个数的的冒泡排序。只需要进行n-1次冒泡；

二.程序部分

//冒泡排序原理:
//就是通过n-1次的两两比较，将最大或者最小的数沉底(也就是所谓的冒泡).
#include<iostream>
#include<string>
#include<ctime>
using namespace std;

void Bubble_sort1(int a[],int n);
void Bubble_sort2(int a[], int n);
void Bubble_sort3(int a[], int n);
void mySwap(int &a, int &b);

int main()
{
    int a[] = { 5,2,4,3,1 };
    Bubble_sort3(a, 5);
    for (int i = 0; i < 5; i++)
        cout << a[i] << " ";

    system("pause");

}

//冒泡排序衍生品
void Bubble_sort1(int a[], int n)
{
    for (int i = 0; i < n; i++)
    {
        for (int j = i + 1; j < n; j++)
        {
            if (a[i] > a[j])
            {
                mySwap(a[i], a[j]);
            }
        }
    }
}

//正宗的冒泡排序
void Bubble_sort2(int a[], int n)
{

    for (int i = 0; i < n-2; i++)
    {
        for (int j = 0; j < n-2-i; j++)
        {
            if (a[j] > a[j+1])
            {
                mySwap(a[j], a[j+1]);
            }
        }
    }
}

//优化的冒泡排序
void Bubble_sort3(int a[], int n)
{
    bool flag = true;
    for (int i = 0; i < n - 1&&flag; i++)
    {
        flag = false;
        for (int j = 0; j < n - 1-i; j++)
        {
            if (a[j] > a[j + 1])
            {
                mySwap(a[j], a[j + 1]);
                flag = true;
            }
        }
    }
}


//两个数的交换函数
void mySwap(int &a, int &b)
{
    int temp;
    temp = a;
    a = b;
    b = temp;
////}