冒泡排序

大家好，我是Matrixap-11,今天给大家带来一个小小的冒泡排序。大一的时候就开始学习冒泡排序了，可是一直没懂，今天算是把冒泡排序搞懂了，虽然现在网上都有各个大佬写的算法，大同小异，可是还是愿意给大家分享一下，谢谢。

1、冒泡排序原理：
对提供的一个序列，将相邻的两个元素进行比较（从小到大排序），每次排序找到未排序序列中的一个最大值，并且将这个最大值冒泡到序列的末尾，完成一次排序，多次排序就可以完成对序列排序。

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

3、举个栗子：
一个待排序的序列是：12 8 2 1 3 6 9 5
第一次排序 （待排序列：12 8 2 1 3 6 5）
12 > 8 =>8 12 2 1 3 6 5；
12 > 2 =>8 2 12 1 3 6 5；
12 > 1 =>8 2 1 12 3 6 5；
12 > 3 =>8 2 1 3 12 6 5；
12 > 6 =>8 2 1 3 6 12 5；
12 > 5 =>8 2 1 3 6 5 12；
本次排序中最大值：max=12，在序列中找到一个最大值并将其排列到序列末尾，完成一次排序。

第二次排序（待排序列：8 2 1 3 6 5 12）
8 > 2 =>2 8 1 3 6 5 12；
8 > 1 =>2 1 8 3 6 5 12；
8 > 3 =>2 1 3 8 6 5 12；
8 > 6 =>2 1 3 6 8 5 12；
8 > 5 =>2 1 3 6 5 8 12；
本次排序中最大值：max=8，排序完成

然后经过多次排序，最后可以得到：1 2 3 5 6 8 12 的一个排好序的序列

4、算法效率分析：
最好：即原来的序列已经是排序完成的，冒泡排序只需要比较一次，时间复杂度O(1)
最坏：假设需要排序的顺序是：从小到大，而原序列是完全的从大到小排序，时间复杂度为**O(nn)***，f(n)=n(n-1)/2;
平均效率：O(nn)*

5、算法实现部分：

void BubbleSort(int *p,int n)
{
    int temp;
    for(int i=0;i<n-1;i++)
    {
        for(int j=1;j<n-i;j++)
        {
            if(p[j-1]>p[j])
            {
                temp=p[j];
                p[j]=p[j-1];
                p[j-1]=temp;
            }
        }
    }
}

6、实例

#include <iostream>

using namespace std;

void BubbleSort(int *p,int n)
{
    int temp;
    for(int i=0;i<n-1;i++)//i轮
    {
        for(int j=1;j<n-i;j++)//每轮下面的比较
        {
            if(p[j-1]>p[j])
            {
                temp=p[j];
                p[j]=p[j-1];
                p[j-1]=temp;
            }
        }
    }
}

int main()
{
    int p[9]={12,8,2,1,3,6,5,9,7};//一个简单的测试数组
    for(int j=0;j<9;j++)
    {
        cout<<p[j]<<" ";
    }
    cout<<endl;
    int len=sizeof(p)/sizeof(p[0]);//用来计算数组的元素个数
    BubbleSort(p,len);//函数调用
    for(int i=0;i<9;i++)
    {
        cout<<p[i]<<endl;
    }
    return 0;
}

注：
联系方式：
qq:2218787597
邮箱：2218787597 @qq.com
这里有各个版本的冒泡排序的链接，分享给大家：
https://baike.baidu.com/item/冒泡排序/4602306?fr=aladdin#3_19