排序算法不会？？？来用Python学，贼简单

1. 冒泡排序

   冒泡冒泡，是将石头丢下去，才会有个泡泡冒起来，顾名思义，我们创建一个for循环，从后往前遍历，这样就实现了每次遍历都会剔除掉最后一个元素的操作，这恰好是我们所需要的（因为冒泡排序的内循环就是将最大元素移动到最后的位置）
   在内循环中，我们从头开始遍历，每一次都会比较当前点和下一个点比较，满足条件就交换，一直循环下去，这样就会在一轮循环中将一个最大的元素移动到最后，此时我们执行外循环，进行新一轮的大元素的后移操作。

   # -*- conding:UTF-8 -*-
   
   
   def bubble_sort(lists):
       '''冒泡排序'''
       for i in range(len(lists)-1, 0, -1):
           # 每次循环会得到最大的，使用range(len(lists)-1, 0, -1)，则是模拟剪掉最大元素位置
           for j in range(i):
               # 按照顺序开始进行比较，将最大元素移送到最后
               if lists[j] > lists[j+1]:
                   lists[j], lists[j+1] = lists[j+1], lists[j]
       return lists
   

2. 选择排序

   选着排序中假设for循环为游标移动，就相当于两个快慢性格的人，慢游标移动一格，快游标则是在当前漫游标的位置开始向右移动，一直到末尾；此时漫游标再右移动一格，快游标再次重复上述操作。
   在快游标移动过程中，它需要做比较操作，若是比漫游标位置处的 元素要小，则记录一下，然后再右移，若是再遇到一个元素比在途中遇到的还小，则重新记录一下，最终快游标一一循环走完，跳出循环时，需要做一下小小的判断，若是记录的最小元素的索引比初始的要小，则交换一下位置，否则不做操作。

   # -*- conding:UTF-8 -*-
   
   
   def select_sort(lists):
       '''选择排序'''
       for i in range(len(lists)-1):
           # 建立起始下标开始遍历，利用range的特性，依次开始遍历每一个下标
           min_index = i
           for j in range(i+1, len(lists)):
               # 针对元素进行遍历，与第一个元素相比较，将最小元素索引保留并返回
               if lists[j] < lists[min_index]:
                   min_index = j
           if min_index != i:
               # 判断最小索引是否应该在合适位置，不在，则进行交换
               lists[i], lists[min_index] = lists[min_index], lists[i]
       return lists
   

3. 插入排序

   相当于创建两个游标，第一个游标一直向前走，不回头的那种，而第二个游标则是获取第一个游标的位置之后往回走。
   当第一个游标向右移动一格，此时我们就开始将当前游标下的元素和前一个元素比较，在相应条件（小于或者大于）下进行交换操作，一直到第二个游标完全逆向遍历完，跳出循环，此时第一个游标向右再走一格，然后第二个游标往回走…
   这里说一个小技巧，就是第二个游标在往回遍历时，若是已经遍历到超出我们设置的条件时，可以做break操作，原因是之前的数其实就是升序或者降序，效果就是可以节省时间。

   # -*- conding:UTF-8 -*-
   
   
   def insert_sort(lists):
       '''插入排序'''
       for i in range(len(lists)-1):
           for j in range(i+1, 0, -1):
               if lists[j] < lists[j-1]:
                   lists[j], lists[j-1] = lists[j-1], lists[j]
               else:
                   break
       return lists
   

4. 快速排序

   从数列中挑选一个元素，我们称之为“基准”（这里我们选择最后一个元素），然后创建两个游标，分别在数列头部和数列尾部-1的位置，前游标向后移动（保证游标大小不可以大于后游标），遇到的元素大于尾部元素，则暂停！此时后游标向前移动（保证游标大小不可以小于前游标），遇到的元素小于尾部元素则暂停，然后交换两个游标指向的元素；然后再去处理游标的移动，若是前游标小于后游标，这继续移动，一直到两个游标重合，此时和最后的元素相比较，然后交换。此时就会实现一个数列的分割，变为左右两个部分，使用递归的方法对余下部分进行处理即可。

   # -*- coding:UTF-8 -*-
   
   
   def quick_sort(lists,left,right):
       '''快速排序'''
   
       # 递归结束条件
       if left > right:
           return 
   
       base_num = lists[right]
       start = left
       end = right
   
       while start < end:
           # 前游标
           while start < end and lists[start] <= base_num:
               start += 1
   
           # 后游标
           while start < end and lists[end] >= base_num:
               end -= 1
   
           # 交换游标指向的元素
           lists[start], lists[end] = lists[end], lists[start]
   
           # 若是游标指向同一元素地址，则讲该元素和最后面的一个元素
           if start == end:
               lists[end], lists[right] = lists[right], lists[end]
       # 左边递归
       quick_sort(lists, left, start-1)
       
       # 右边递归
       quick_sort(lists, start+1, right)
   

5. 希尔排序

   可以简单理解为插入排序的变种,是将整个有序序列分割成若干小的子序列分别进行插入排序。

   # -*- coding:UTF-8 -*-
   
   
   def shell_sort(lists):
       '''希尔排序'''
       sublistcount = len(lists) // 2
       while sublistcount > 0:
           for i in range(sublistcount):
               gap_insert_sort(lists, i, sublistcount)
           sublistcount //= 2
       return lists
   
   def gap_insert_sort(lists,start,gap):
       for i in range(start,len(lists)-1, gap):
           for j in range(i+1,0,-gap):
               if lists[j] < lists[j-gap]:
                   lists[j], lists[j-gap] = lists[j-gap], lists[j]
               else:
                   break
   

6. 归并排序

   归并排序是将原数列分成若干个小份,对每小份进行排序,然后合并的过程。

   # -*- coding:UTF-8 -*-
   
   
   def merge_sort(lists):
       '''归并排序'''
       if len(lists) <= 1:
           return lists
   
       # 使用递归的方式进行切分,并讲切分的数据进行排序后合并
       middle = len(lists) // 2
       left = merge_sort(lists[:middle])
       right = merge_sort(lists[middle:])
   
       merged = []
       while left and right:
           if left[0] < right[0]:
               merged.append(left.pop(0))
           else:
               merged.append(right.pop(0))
   
       merged.extend(right if right else left)
       return merged