算法

Lowb三人组： 冒泡排序，选择排序，插入排序
时间复杂度，（短）：选择跟插入排序差不多，都比冒泡快

冒泡排序（两个相邻元素作比较，值小，交换） O（n2）

思路：

• 需要n-1趟

• 每一趟把无序区每两个相邻元素是大小关系交换

• 第i趟：有序区有i个数，无序区的范围：[0,n-i-1]

    Import random
    def bubblle_sort(li):
        for i in range(len(li)-1): #i表示第i趟 i=0,1,2，，，n-2
            for j in range(len(li)-i-1):
                if li[j]>li[j+1]:
                    li[j],li[j+1] = li[j+1],li[j]
            # print(li)
    # li = [5,2,6,7,1,3]
    li = list(range(10000))
    random.shuffle(li)  
    bubblle_sort(li)
    print(li)
  

选择排序：（第一个值不动，从第二个值往后找，找到最小的跟第一个值交换） O(n2)

思路：

• 一趟遍历记录最小的数，放到第一个位置，

• 再一趟遍历记录剩余列表中最小的数，继续放置

• ..........
  

  def selext_sort(li):
  for i in range(len(li)-1): #一共n-1趟
  min_pos = i #min_pos记录无序区最小值的位置
  for j in range(i+1,len(li)):
  if li[j]<li[min_pos]:
  min_pos = j
  li[i],li[min_pos] = li[min_pos],li[i]
  print(li)
  li = [256,35,7,5,45,23]
  selext_sort(li)
  print(li)

插入排序 （牌） O(n2)

思路：
列表被分成有序区和无序区两部分。最初有序区只有一个元素
每次从无序区选择一个元素，插入到有序区的位置，直到无序区变空

def insert_sort(li):
    for i in range(1,len(li)): #i表示摸到的牌（或是要插入的数）的下标
        tmp = li[i] #把摸到的牌存起来
        j = i-1   #j是有序区要比较的数的下标
        while j>=0 and li[j] > tmp:  #决定什么时候停止循环，把tmp插入到对应位置上
            # 两个终止条件：1. j位置的值比tmp小。2. j=-1 已经移动到最前面的
            li[j+1] = li[j]
            j -=1  #j =  0-1
        li[j+1] = tmp
        print(li)
li=[145,2,456,45,8]
insert_sort(li)

快速排序

取一个元素p（第一个元素），是元素P归位
列表被p分成两部分，左边都比p小，右边都比p大
递归完成排序

def partition(li,left,right):
    tmp=li[left]
    while left < right:
        while left < right and li[right] >= tmp:
            right -=1
        li[left] = li[right]
        while left < right and li[left] <= tmp:
            left +=1
        li[right] = li[left]
    li[left] = tmp  #两个指针碰到一起
    return left
li = [5,7,4,6,3,1,2,9,8]
print(partition(li,0,len(li)-1))
print(li)