冒泡排序
1、思路：首先，列表每两个相邻的数比较大小，如果前边的比后边的大，那么这两个数就互换位置。就像是冒泡一样
2、代码关键点：
- 趟数：n-1趟
- 无序区
时间复杂度：O(n2)
def bubblr_sort(li): for i in range(len(li)-1):#排序的次数 change = False for j in range(len(li)-i-1): #表示无序区，无序区的范围为0,len(li)-i-1 if li[j] > li[j+1]: li[j],li[j+1] = li[j+1],li[j] change = True if not change: return li = list(range(5)) import random random.shuffle(li) print(li) bubblr_sort(li) print(li)
选择排序
1、思路：一趟遍历完记录最小的数，放到第一个位置；在一趟遍历记录剩余列表中的最小的数，继续放置
2、代码关键点：
- 无序区
- 最小数的位置
3、问题：怎么选出最小的数？
时间复杂度：O(n2)
import random def select_sort(li): for i in range(len(li)-1): #i 表示躺数，也表示无序区开始的位置 min_loc = i #最小数的位置 for j in range(i+1,len(li)): #i ,i+1，就是后一个位置的范围 # [9, 2, 1, 6, 5, 8, 3, 0, 7, 4] # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] if li[j] <li[min_loc]: #两个位置进行比较，如果后面的一个比最小的那个位置还小，说明就找到最小的了 min_loc = j #找到最小的位置 if min_loc !=i: li[i],li[min_loc] = li[min_loc],li[i] #吧找到的两个值进行互换位置 li = list(range(10)) random.shuffle(li) print(li) select_sort(li) print(li)
插入排序
1、思路：元素被分为有序区和无序区两部分。最初有序区只有一个元素。每次从无序区中选择一个元素，插入到有序区的位置，直到无序区变空。
2、代码关键点：
- 摸到的牌
- 手里的牌
3、图示说明
时间复杂度O(n2)
插入后：
4、代码示例
import random def insert_sort(li): for i in range(1,len(li)): #i 表示无序区的第一个数 tmp = li[i] #摸到的牌 j = i-1 #指向有序区最后一个位置 while li[j] >tmp and j>=0: #循环终止条件 li[j]<=tmp and j==-1 li[j+1] = li[j] #向后移动 j-=1 li[j+1] = tmp li = list(range(10)) random.shuffle(li) print(li) insert_sort(li) print(li)
快速排序
1、思路：1、取一个元素p(第一个元素)，是元素p归位（去它该去的地方）；
2、列表被p分成两部分，左边的都比p小，右边的都比p大；
3、递归完成排序
2、算法关键点
- 归位
- 递归
3、图示说明
4、怎么归并呢？先把5取出来，这时候就会有一个空位，从右边找比5小的数填充过来，现在右边有一个空位了，从左边找比5大的放到右边的空位上。依次类推，
只要left和right碰在一起，这样就找打5的位置了
如图示：
图一
图二
图三
图四
这样在把找到的5的位置放进去去ok了
5、代码示例
# 快速排序 def quickSort(li): if li: mark=li[0] little=[m for m in li if m<mark] big=[x for x in li if x>mark] return quickSort(little)+[mark]+quickSort(big) else: return [] if __name__=='__main__': li = [3,44,38,5,47,15,36,26,27,2,46,4,19,50,48] print(quickSort(li))
归并排序
假设现在的列表分两段有序，如何将其合成为一个有序列表。这种操作称为一次归并
1、思路：
2、归并关键字
- 分解：将列表越分越小，直至分成一个元素
- 终止条件：一个元素是有序的
- 合并：将两个有序列表归并，列表越来越大
3、图实示例：https://www.cnblogs.com/chengxiao/p/6194356.html
4、代码示例：
import random def merge(li, low, mid, high): # 一次归并 ''' :param li: 列表 :param low: 起始位置 :param mid: 按照那个位置分 :param high: 最后位置 :return: ''' i = low j = mid + 1 ltmp = [] while i <= mid and j <= high: if li[i] < li[j]: ltmp.append(li[i]) i += 1 else: ltmp.append(li[j]) j += 1 while i <= mid: ltmp.append(li[i]) i += 1 while j <= high: ltmp.append(li[j]) j += 1 li[low:high+1] = ltmp def _merge_sort(li, low, high): if low < high: # 至少两个元素 mid = (low + high) // 2 _merge_sort(li, low, mid) _merge_sort(li, mid+1, high) merge(li, low, mid, high) print(li[low:high+1]) def merge_sort(li): return _merge_sort(li, 0, len(li)-1) li = list(range(16)) random.shuffle(li) print(li) merge_sort(li) print(li) 归并排序
归并排序的时间复杂度：O(nlogn)，空间复杂度是：O(n)
希尔排序
希尔排序是一种分组插入排序算法。
首先取一个整数d1=n/2，将元素分为d1个组，每组相邻量元素之间距离为d1，在各组内进行直接插入排序；
取第二个整数d2=d1/2，重复上述分组排序过程，直到di=1，即所有元素在同一组内进行直接插入排序。
希尔排序每趟并不使某些元素有序，而是使整体数据越来越接近有序；最后一趟排序使得所有数据有序
def shell_sort(alist): n = len(alist) # 初始步长 gap = n // 2 while gap > 0: # 按步长进行插入排序 for i in range(gap,n): j = i # 原地插入排序，之前的插入排序另辟空间存储的 while j>=gap and alist[j-gap] > alist[j]: alist[j-gap], alist[j] = alist[j], alist[j-gap] j -= gap # 得到新的步长 gap = gap //2 alist = [54,26,93,17,77,31,44,55,20] shell_sort(alist) print(alist)
LOw B 三人组
- 冒泡排序，选择排序，直接插入排序他们的时间复杂度都是O(n^2),空间复杂度是O(1)
NB 三人组
- 快速排序，归并排序，堆排序他们的时间复杂度都是O(nlogn)
- 三种排序算法的缺点
- 快速排序：极端情况下排序效率低
- 归并排序：需要额外的内存开销
- 堆排序：在快的排序算法中相对较慢
