【数据结构】——交换排序算法：冒泡排序、快速排序

一、冒泡排序：（稳定）

1.基本思想

  成对比较：

1. 比较相邻元素，若第一个大于第二个，则交换
2. 对每一对相邻元素做同样工作，这一步完成后最后的元素将是最大的数
3. 针对所有元素重复以上过程（除去排好序的数字）
4. 没有任何一对元素发生交换时，停止排序

2.代码实现

#冒泡排序
m=[1,3,4,2]
def Bubble_sort(alist):
    n=len(alist)
    count=False
    for i in range(0,n-1):#循环每一对
        for j in range(0,n-1-i):#已经排好的下次不再参与排序
            if alist[j]>alist[j+1]:
                alist[j],alist[j+1]=alist[j+1],alist[j]      
                count=True
        if count==False:#说明当前排序顺序没有改变
            return alist
    return alist
Bubble_sort(m)
>>[1, 2, 3, 4]

3.时间复杂度

  平均：O（n^2）:因为有两层for循环，每次为n，所以为n*n
  最好：O(n):当输入顺序即为升序时，只需遍历一遍即可
  最坏：O（n^2）：所有的均为乱序，挨个循环一次

二、快速排序：（不稳定）

1.基本思想

  递归思想：

1. 从序列中选出一个元素作为基准
2. 比基准小的元素排在基准前面，比基准大的排在基准后面，相同的可任选前面或后面
3. 递归的把小于基准的元素子序列、大于基准的元素子序列进行排序

2，代码实现

#快速排序
m=[1,3,4,2]
def quick_sort(alist,start,end):
    if start >=end:
        return
    low=start
    high=end
    middle=alist[low]
    while low<high:
            while low<high and alist[high]>=middle:
                high-=1
            alist[low]=alist[high]
            while low<high and alist[low]<=middle:
                low+=1
            alist[high]=alist[low]
    alist[low]=middle
    quick_sort(alist,start,low-1)
    quick_sort(alist,low+1,end)
quick_sort(m,0,len(m)-1)
print(m)
>>[1, 2, 3, 4]

3.时间复杂度

从递归考虑时间复杂度。
            平均：O（nlogn）
            最好：O（nlogn）
            最坏：O(n^2)

第一次排序：

  其中（T（n/2））是每次分出的两个子序列的时间复杂度，n是每次划分子

序列时找到对应位置，遍历一遍的复杂度为n。

第二次排序：

第三次排序：

……………

第m次排序：

故时间复杂度为：