算法---冒泡排序

1.核心算法：

第一遍：冒泡取第一个数和第二个数进行比较，如果X(i)>X(i+1),就调换。这么遍历完一遍后，最后一个元素（n）是序列里最大的一个数。

第二遍：第一个数和后面的数进行比较，如果X(i)>X(i+1),就调换，一直到倒数第二个元素(n-1)。

总共需要遍历 n-1。

核心思想：遍历n-1次

 2.排序过程：

数组：12 23 34 2 31
    （12 23 2 34 31）

第一次遍历：12 23 2 31 34 

第二次遍历：12   2  23 31  34

第三次遍历： 2  12  23 31  34
。。。（此处为什么没有第4次，因为第3次已经排好了）

 3.一个数组有n个元素，需要遍历几次才能得到排序结果

 答案：n-1

4.实现的代码

# encoding=utf-8

def bubbleSort(listx):
    xLen = len(listx)
    for i in xrange(xLen-1):
        for j in xrange(xLen-1-i):
        #for j in xrange(xLen - 1):
            if listx[j] > listx[j+1]:
                listx[j],listx[j+1] = listx[j+1],listx[j]
    return listx

if __name__ == '__main__':
    print bubbleSort([32,34,1,3,45])

对上述代码的理解：

1. 第一个for循环决定比较多少次。i---控制遍历多少次
2. 第二个for循环决定每次循环要干什么事。j---控制每次比较元素的下标

5.for j in xrange(xLen-1-i) 修改成 for j in xrange(xLen-1),功能是否正确，弊端在哪里？

不影响最终结果，但是排序过程会多比较那些没有必要再去比较的下标。

6.将以上代码改为从大到小的排序

# encoding=utf-8
  
  def bubbleSort(listx):
      xLen = len(listx)
      for i in xrange(xLen-1):
          for j in xrange(xLen-1-i):         #for j in xrange(xLen - 1):
              if listx[j]< listx[j+1]:
                  listx[j],listx[j+1] = listx[j+1],listx[j]
      return listx
  
  if __name__ == '__main__':
      print bubbleSort([32,34,1,3,45])

 7.时间复杂度：去干某个事情，所消耗的计算次数

 O(1)<O(logn)<O(n*logn)<O(n^2)<O(n^3)…<O(2^n)<O(n!)

 8. 针对一个数组x[n]进行冒泡排序，需要比较多少次？

第一次比较：n-1次

第二次比较：n-2次

…

第n-1次比较：1次

一共：(n-1)+(n-1)+…+1=(n-1+1)(n-1)/2=n(n-1)/2

N^2/2-n/2

O(n*2)

 9.如何计算时间复杂度

1. 得到算法的计算次数
2. 把计算次数中，保留最大的项式，去掉其它的项式
3. 把最大项式的因子去掉
4. 匹配上述公式，得到O表示的时间复杂度

10.冒泡排序的时间复杂度是多少？

O(n^2)