常见的排序算法

衡量算法快慢的标准

• 时间复杂度
  
• 空间复杂度--占用的内存空间

时间复杂度是衡量算法好坏的一个标准， 主要看程序^大概^运行的次数 
用 O()表示 

while n>1:
    print(n)
    n=n//2
此时 时间复杂度是O（log2 N)

1. 常见的时间复杂度（按效率排序）

O(1)<O(logn)<O(n)<O(nlogn)<O(n2)<O(n2logn)<O(n3)

mysql底层b+tree 时间复杂度相当于 O（logn） 仅次于 O（1）

2. 如何一眼判断时间复杂度？

? 循环减半的过程O(logn)
? 几次循环就是n的几次方的复杂度

• 冒泡排序

  时间复杂度O(n^2^)  最优的复杂度是O(n)
  def Bubble_sort(list):
      for i in range(len(list)-1):
          flag=True    #优化排序 设定一个flag
          for j in range(len(list)-1-i):
              if list[j]>list[j+1]:
                  list[j],list[j+1]=list[j+1],list[j]
                  flag=False    # 只要走过一次循环就会更改这个值
          if flag:      #若一次循环条件if没走到，换一句话讲就是li是一个有序的
              return   
  
  
  li=[7,9,6,4,8,5,1,2,3]
  print(len(li))
  Bubble_sort(li)
  

• 选择排序 --和冒泡排序差不多

  def select_sort(li):
      for i in range(len(li)):
          min_loc = i
          for j in range(i+1,len(li)):
              if li[min_loc]>li[j]:
                  li[min_loc],li[j] = li[j],li[min_loc]
  
  li=[7,9,6,4,8,5,1,2,3]
  select_sort(li)
  print(li)

• 插入排序

  思路：列表被分为有序区和无序区两个部分。

  最初有序区只有一个元素。
  每次从无序区选择一个元素，插入到有序区的位置，直到无序区变空。

  def insert_sort(li):
      for i in range(1,len(li)):
          tmp = li[i]
          j = i-1
          while j >= 0 and li[j]>tmp:
              li[j+1] = li[j]
              j = j-1
          li[j+1]=tmp
  
  li=[7,5,4,9,8,6,1,2,3]
  insert_sort(li)
  print(li)

• 快速排序

  思路：取一个元素 （第一个元素） ，使得它归位

  列表被分为两部分，左边都是比这个数小的，右边都是比这个数大

  def partition(data,left,right):
      tmp = data[left]
      while left<right:
          while left<right and data[right]>tmp:
              right = right-1
          data[left]=data[right]
          while left<right and data[left]<tmp:
              left = left+1
          data[right]=data[left]
  
      data[left] = tmp
      return left
  def quick_sort(data,left,right):
      mid = partition(data,left,right)
      partition(data,left,mid)
      partition(data,mid+1,right)
  
  
  li=[7,5,4,9,8,6,1,2,3]
  quick_sort(li,0,len(li)-1)
  print(li)