常见的排序算法

衡量算法快慢的标准

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

时间复杂度是衡量算法好坏的一个标准， 主要看程序^大概^运行的次数 
用 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)
      quick_sort(data,left,mid)
      quick_sort(data,mid+1,right)
  
  
  li=[7,5,4,9,8,6,1,2,3]
  quick_sort(li,0,len(li)-1)
  print(li)
  
  

• 快排2

  def quicksort(list):
      if len(list)<2:
          return list
      else:
          midpivot = list[0]
          lessbeforemidpivot = [i for i in list[1:] if i<=midpivot]
          biggerafterpivot = [i for i in list[1:] if i > midpivot]
          finallylist = quicksort(lessbeforemidpivot)+[midpivot]+quicksort(biggerafterpivot)
          return finallylist
  
  print quicksort([2,4,6,7,1,2,5])
  

• 计数排序

    def count_sort(li):
      count = [0 for _ in range(len(li)+1)]
      for i in li:
          count[i]+=1
      print(count)
      li.clear()
      for n,num in enumerate(count):
          print(n,num)
          for j in range(num):
              # print(n)
              li.append(n)
      print(li)
  
  
  li=[7,5,4,9,8,6,1,2,3,8,7,9,11,11]
  count_sort(li)
  

• 贪心算法

  
  money = [100,50,20,10,5,2,1]
  
  def howManyCash(money, num, waitToPay):
  
      count = 0
  
      for i in range(num):
          useMoney = waitToPay//money[i]
  
          count += useMoney
          waitToPay = waitToPay - useMoney*money[i]
  
          print("需要面额为 %d 的 %d 张" % (money[i],useMoney))
          print("剩下需要支付 RMB %d \n" % waitToPay)
      print("总共需要%d张RMB\n"%count)
  howManyCash(money, len(money), 628)