算法

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)

快速排序 o(nlogn)

取一个元素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
def sor(li,left,right):
    if left < right:
        mid  = partition(li, left, right)
        sor(li, left, mid - 1)
        sor(li, mid + 1, right)

li = [5,7,4,6,3,1,2,9,8]
print(sor(li,0,len(li)-1))
print(li)
——————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————

方法二

def quit_sort(arr, left, right):
    """快速排序算法
        思想：快速排序是效率最高的排序算法之一,
        1.先以一个基准开始（通常为第一个数）
        2.从右边开始找到第一个比基准小的数
        3.从左边开始找到第一个比基准大的数
        4.将比基准小的数和比基准大的数调换位置
        5.继续从右往左以及从左往右调到对应的数，直到二边重合结束
        6.将基准的数与重合的数调换位置，这是基准左边都是小的数，右边都是大的数
        7.重复1,2,3,4对左右两边的数进行排序
    """
    # 列表长度大于1
    if len(arr) <= 1 or left > right:
        return
         # 定义基准
    temp = arr[left]
    # 定义从左边开始的数(基准的下一个数)
    i = left
    # 定义从右边开始的数（要判断的末尾）
    j = right
    # 一直循环到从左边开始的碰到从右边开始的
    while i < j:
        # 从右边开始的一直循环到第一个比基准小的数且没有碰头为止
        while arr[j] >= temp and i < j:
            j -= 1
        # 从左边开始的一直循环到第一个比基准大的数且没有碰头为止
        while arr[i] <= temp and i < j:
            i += 1
        # 当在两边找到符合条件且没有碰头的数据时，将数据调换位置
        if i < j:
            mTemp = arr[j]
            arr[j] = arr[i]
            arr[i] = mTemp
        # 继续往下循环找到所有的符合条件的并调换位置

    # 到这里当前基准循环完毕，将当前基准和结束循环的位置数调换，使得基准左边都是小于基准的数，右边都是大于基准的数
    arr[left] = arr[i]
    arr[i] = temp

    # 继续将基准两边的数进行以上操作
    quit_sort(arr, left, j-1)
    quit_sort(arr, j+1, right)
    
#定义一个列表 
arr = [2, 3, 1, 5, 10, 6, 3, 4, 8] print(arr) quit_sort(arr, 0, len(arr) - 1) print(arr)