001冒泡排序python实现

冒泡排序法的原理如下：
我们拿升序这个情况来进行讲解，假设有五个数字，原始序列为：5、4、3、2、1
接下来呢，我们需要让他们升序排列，变为：1、2、3、4、5
这个时候冒泡排序的过程是这样的
第一轮：
第一次：此时比较第一个和第二个数字，情况有如下三种：
        第一种：第一个数字大于第二个数字
        第二种：第一个数字等于第二个数字
        第三种：第一个数字小于第二个数字

        接下来就上述三种情况进行比较运算：
        当第一个数大于第二个数时，则需要交换第一个数和第二个数，交换完之后，此时序列的第一个数字小于第二个数字。
        当第一个数等于第二个数时，则不需要交换两个数字，此时序列的第一个数字等于第二个数字。
        当第二个数小于第二个数时，则不需要交换两个数字，此时序列的第一个数字小于第二个数字。

        总结：第一个数字大于时，需要交换，其他情况不需要交换，目的是保证第二个数一定要大于或者等于第一个数。
        此时，经过第一次比较之后，第二个数字一定大于或者等于第一个数字
        第一次比较之后的结果为：4、5、3、2、1

第二次：比较第二个数字和第三个数字，此时注意：经过第一次的比较，第二个数字一定是大于或者等于第一个数字。
        继续进行比较运算，当这次执行完毕之后，第三个数字一定大于或者等于第二个数字
        此时需要注意：经过两次比较，第三个数字大于或等于第一个和第二个数字，但是此时第二个和第一个谁大谁小不知道。
        第二次比较之后的结果为：4、3、5、2、1

第三次：比较第三个和第四个数字，此时注意：经过前面的比较步骤，第三个数一定是大于或者等于前面两个数。
        继续进行比较运算，当这次执行完毕之后，第四个数字一定大于或者等于第三个数字。
        此时需要注意：第四个数字大于或等于前面三个数字，但是前面三个数字谁大谁小不知道。
        第三次比较之后的结果为：4、3、2、5、1

第四次：比较第四个和第五个数字（本序列的最后一个数字），此时注意：经过前面的比较步骤，第四个数一定是大于或者等于前面三个数。
        继续进行比较运算,当本次执行完毕之后，第五个数字一定是大于或者等于第四个数字。
        此时需要注意：第五个数字大于或者等于前面四个数字，但是前面四个数字谁大谁小不知道。
        经过这次比较之后，第五个数字就是最大的数字了。
        第四次比较之后的结果为：4、3、2、5、1
        此时第一轮结束，但是前面四个数字的大小情况仍然不知道，仍然需要进一步排序。

第二轮开始：此时注意，由于经过了第一轮，最大的数字已经放到了最后的位置上，所以，此时只需要比较前面的四个数字，把四个数字中的
最大的数字放到四个位置上即可。
第一次：比较第一个和第二个数字，进行比较运算，结束后第二个数字大于或等于第一个数字。
第二次：比较第二个和第三个数字，进行比较运算，结束后第三个数字大于或等于第二个数字。
第三次：比较第三个和第四个数字，进行比较运算，结束后第四个数字大于或等于第三个数字。
此时，序列情况为：3、2、1、4、5
此时，最大的数字放到了四个位置上，前面三个数字大小情况仍然未知，需要进一步比较。

第三轮开始：此时注意，由于经过了前两轮，最大的两个数字已经放到了正确的位置上，所以，此时只需要比较前面的三个数字，把三个数字中的
最大的数字放到第三个位置上即可。
第一次：比较第一个和第二个数字，进行比较运算，结束后第二个数字大于或等于第一个数字。
第二次：比较第二个和第三个数字，进行比较运算，结束后第三个数字大于或等于第二个数字。
此时，序列情况为：2、1、3、4、5
此时，三个中最大的数字放到了三个位置上，前面两个数字大小情况仍然未知，需要进一步比较。

第四轮开始：此时注意，由于经过了前三轮，最大的三个数字已经放到了正确的位置上，所以，此时只需要比较前面的两个数字，把最大的
放到第二个位置上即可。
第一次：比较第一个和第二个数字，重复比较的步骤，结束后第二个数字大于或等于第一个数字。
序列情况为：1、2、3、4、5
此时，所有数字比较完毕，整个比较过程结束。

就本案例全部的比较过程，我们可以进行一下总结
首先，本案例的序列有五个数字，共经过了四轮比较，每轮经过若干次比较，最后把序列中的数字按照升序排序完成，
每一轮，把参与比较的最大的数字放到最后的位置上。
最后一轮由于只剩两个数字，所以只需要把其中一个放到对应位置上，另一个就无需进行比较了。
5个元素需要经过4轮，则n个元素则需要经过n-1轮。

每一轮都需要经过若干次比较，共同点为每次需要比较相邻的两个数字，
第一次为a1和a2，
第二次为a2和a3，
第三次为a3和a4,
第四次为a4和a5
以此类推。
第n-1次为an-1 和 an
所以每轮需要比较的次数为参与排序的元素的个数减1，当参与比较的个元素个数数为5个时，则需要比较4次。
n个元素则需要经过(n-1)次比较

如果有n个元素
第一轮：参与比较的元素个数为n个，共需要经过n-1次比较
第二轮：参与比较的元素个数为n-1个，共需要经过n-2次比较
...
第n-1轮：参与比较的元素个数为2个，共需要经过1次比较。
总次数为：n-1 + n-2 + ... + 1

如果有n个元素，那么共需要经过n-1轮比较，共需要经过n(n-1)/2次比较。

上述案例我们每次把正确的数字放到了最后面，同样的我们也可以每次把正确的数字放在最前面，
所以，冒泡排序的精华如下：
每一轮，都把正确的数字放到最后面或者最前面，n个数字共需要经过n-1轮。
每一轮都需要经过若干次，每次依次比较前两个数字，共需要经过参与比较的元素个数-1次。
n个元素的比较共需要n轮，共需要(n-1)/2次

接下来是代码实现部分
# 每次都把正确的数放到最后面
def sort_bubble01(array):
    length = len(array);
    for i in range(length-1): # 共进行n-1 轮
        for j in range(length-i-1): # 共进行参与比较的元素个数-1次
            if array[j] > array[j+1]: # 比较两个数字，如果前小于后则交换
                array[j], array[j+1] = array[j+1], array[j];
    return array;

# 每次都把正确的数放到最前面
def sort_bubble02(array):
    length = len(array);
    i = 0;
    while i < length-1: # 共进行n-1轮
        j = length-1;
        while j > i: # 共进行参与比较的元素个数-1次
            if array[j] < array[j-1]: # 比较两个数字，如果后小于前则交换
                array[j], array[j-1]  = array[j-1], array[j];
            j -= 1;
        i += 1;
    return array