基础算法——冒泡排序

本算法只针对算法小白或者刚刚学习编程的同学，大神勿喷！！

冒泡排序是最最基础的一个排序算法，虽然简单，但对于理解计算机程序的运行方式很有帮助！

现在对a = [6,2,4,3,5,1]进行从大到小的排序，冒泡排序的思路是这样的：

第一轮排序：

先从a[0]和a[1]开始比较，a[0]>a[1]，所以a[0]和a[1]调换位置，数列变成了[2,6,4,3,5,1]，

然后a[1]和a[2]开始比较，a[1]>a[2]，所以a[1]和a[2]调换位置，数列变成了[2,4,6,3,5,1]，

然后a[2]和a[3]开始比较，a[2]>a[3]，所以a[2]和a[3]调换位置，数列变成了[2,4,3,6,5,1]。

然后a[3]和a[4]开始比较，a[3]>a[4]，所以a[3]和a[4]调换位置，数列变成了[2,4,3,5,6,1]。

然后a[4]和a[5]开始比较，a[4]>a[5]，所以a[4]和a[5]调换位置，数列变成了[2,4,3,5,1,6]。

通过第一轮比较，我们就把一个最大值6，排到了最后的位置，同时我们也看到了，每一次的比较，6都会往右挪一位，最终挪到了最右侧，像一个气泡一样，一点一点升到了水面上一样，这也是为什么这个算法叫做冒泡排序的原因。

现在最大值找到了，我们开始找第二大的值，操作方式是一样的，现在数列是：

[2,4,3,5,1,6]

第二轮排序：

先从a[0]和a[1]开始比较，但是a[0]<a[1]，我们的目标是把大的数“升”到数列右侧，所以a[0]和a[1]不调换位置，数列仍为[2,4,3,5,1,6]，

然后a[1]和a[2]开始比较，a[1]>a[2]，所以a[1]和a[2]调换位置，数列变成了[2,3,4,5,1,6]。

然后a[2]和a[3]开始比较，a[2]<a[3]，所以a[2]和a[3]不调换位置，数列仍为[2,3,4,5,1,6]。

然后a[3]和a[4]开始比较，a[3]>a[4]，所以a[3]和a[4]调换位置，数列变成了[2,4,3,1,5,6]，

第二大的数也找到了，其他数的排序也是一样的操作，这里不做推导了，但是规律已经很明显了，每一轮排序，确定一个值的位置，如果要对6个数进行排序的话，则需要进行5轮排序即可，（因为5轮排序以后就可以确定5个数的准确位置了，最后1个数的位置自然就被确定了），

第1轮排序，数字两两之间进行了5次比较，第2轮排序，数字两两之间进行了4次比较，所以第3轮排序，数字两两之间就会进行3次比较······，规律如下

第1轮排序	比较5次
第2轮排序	比较4次
第3轮排序	比较3次
第4轮排序	比较2次
第5轮排序	比较1次

根据这个规律，如果要对n个数进行排序，一共需要n-1轮排序，如果当前是第k轮排序的话，那么本轮需要比较的次数为n-k，规律如下：

第1轮排序	比较n-1次
第2轮排序	比较n-2次
第3轮排序	比较n-3次
第4轮排序	比较n-4次
第5轮排序	比较n-5次
``````	``````
第n-1轮排序	比较1次

这是一个典型的双层for循环结构，外层循环控制排序的轮数，内层循环控制每轮比较次数（很多同学大一初学此算法时，最头疼的问题就是不会写循环次数，其实直接按这个公式无脑套入即可）。

代码如下：

a = [6, 2, 4, 3, 5, 1]
for i in range(1, len(a)):
    for j in range(0, len(a) - i, 1):
        if a[j] > a[j + 1]:
            a[j], a[j + 1] = a[j + 1], a[j]
print(a)

（Python实现数组元素交换真的很方便）