各种排序算法

python排序

• 选择排序

  def Select_sort(lst):
      """选择排序"""
      # 找到最小值，放在第一位、第二位...
      for j in range(len(lst)):
          min_value = float('inf')
          for i in range(j, len(lst)):
              min_value = min(min_value,lst[i])
          index = lst.index(min_value)
          lst[j], lst[index] = lst[index], lst[j]
      return lst
  

• 冒泡排序

  def Bubble_sort(lst):
      """ 冒泡排序:
      从后往前，依此比较两个数，直到到达列表第一位，将小的放前面，大的放后面
      遍历完一次，最小值位于列表第一位
      循环，依此比较两个数，直到到达列表第二位（第一位已经是最小值，排好序）
  	 """
      for j in range(len(lst)-1):
          for i in range(len(lst)-1, j, -1):
              if lst[i] <= lst[i-1]:
                  lst[i], lst[i - 1] = lst[i-1], lst[i]
      return lst
  

• 堆排序

  • 1.实现堆排序算法

    def build_heap(lst, root, lens):
        while True:
            child = 2 * root + 1  # 在堆里面（序号从0开始），左孩子是 child = 2 * root + 1，右孩子是child + 1
            if child > lens:  #  超过列表索引
                break
            if child < lens and lst[child] < lst[child+1]:  #  没有超过索引，并且右孩子 > 左孩子
                child += 1  # child 指向右孩子（child指向孩子中最大的，方便与根节点互换）
            if lst[child] > lst[root]:  #  如果孩子 > 父节点
                lst[child], lst[root] = lst[root], lst[child]  #  交换父子结点
                root = child  # 父节点指向之前的孩子结点（准备更换后下次的查找）
            else:
                break
    
    def heap_sort(lst):
        """堆排序"""
        lens = len(lst)
        root = lens // 2 - 1   # 堆的序号从0开始，从最下面非叶子结点开始，一般是lens/2
        for i in range (root, -1, -1):   # 往上查
            build_heap(lst, i, lens-1)
        #  堆建好，每次将第一个 和 最后一个互换，互换完成，最大的已经排好序，长度-1，并且重新进行建堆
        for l in range (lens-1, 0, -1):
            lst[0], lst[l] = lst[l], lst[0]
            build_heap(lst, 0, l-1)
        return lst
    

    • 2.利用库函数 heapq库详解

    def heapsort(lst):
        import heapq
        heapq.heapify(lst)  # 用列表创建堆
        result = [heapq.heappop(lst) for _ in lst ]  # heappop()输出堆里最小值
        return result
    

• 插入排序

  def insert_sort(lst):
      """插入排序：
          从右侧未排序的区域中取出一个数据，然后将它插入到已经排序区域内合适的位置
      """
      lens = len(lst)
      for i in range (1, lens):
          if lst[i] < lst[i-1]:  # 每次和前一个比较，后一个数小的话就交换 
              lst[i], lst[i-1] = lst[i-1], lst[i]
              for j in range(i-1, 0, -1):  # 再比较交换之后的，前后的大小，一直将小的交换到前面去
                  if lst[j] < lst[j-1]:
                      lst[j], lst[j-1] = lst[j-1], lst[j]
                  else:
                      break
      return lst
  

• 快速排序 移步

  def fast_sort(lst, start, end):
      """
      快速排序：
          每次选择一个基准，小于基准的放左边，大于的放右边
          再递归两边的数
      """
      #  递归出口，一定要写
      if start >= end:
          return
      base = division(lst, start, end)
      fast_sort(lst, start, base-1)
      fast_sort(lst, base+1, end)
      return lst
  
  def division(lst, left, right):
      """按照基准将数组分开：默认选择数组第一个数，返回''【小】基准【大】''中的基准索引"""
      base = lst[left]
      base_index = left
      while left < right:
      	# 从右向左，找比基准小的数
          while left < right and lst[right] >= base:
              right -= 1
          # 从左向右，找比基准大的数
          while left < right and lst[left] <= base:
              left += 1
           # 左边比基准大的数 和  右边比基准小 交换
          lst[left], lst[right] = lst[right], lst[left]
         # 换完接着向中心搜索
         
      lst[left], lst[base_index] = lst[base_index], lst[left]
      return left