CH1 排序

桶排序

• 这个算法就好比有 11 个桶，编号从 0~10。每出现一个数，就在对应编号的桶中放一个
  小旗子，最后只要数数每个桶中有几个小旗子就 OK 了。
• eg. 2 号桶中有 1 个小旗子，表示2 出现了一次
  
• 此处的每一个桶的作用其实就是“标记”每个数出现的次数.
• 桶排序的时间复杂度为$O(M+N)$

def bucket_sort(L):
    buckets = [0] * ((max(L) - min(L))+1)
    for i in range(len(L)):
        buckets[L[i]-min(L)] += 1
    res=[]
    for i in range(len(buckets)):
        if buckets[i] != 0:
            res += [i+min(L)]*buckets[i]
    return res
bucket_sort(L)

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10

冒泡排序

• 冒泡排序的基本思想是：每次比较两个相邻的元素，如果它们的顺序错误就把它们交换
  过来。
• 冒泡排序每两个依次比较，直到最后一个尚未归位的数，已经归位的数则无需再进行比较。
• 冒泡排序的时间复杂度是 $O(N^2)$
• 冒泡排序的核心部分是双重嵌套循环。

def bubble_sort(L):
	count = len(L)
	for i in range(0, count):
		for j in range(i+1, count):
			if L[i] > L[j]:
				L[i], L[j] = L[j], L[i]
	return L

• 1
• 2
• 3
• 4
• 5
• 6
• 7

快速排序

• 基本思想：快速排序的每一轮处理其实就是将这一轮的基准数归位，直到所有的数都归位为止，排序就结束了。
• eg.给出 6 1 2 7 9 3 4 5 10 8，第一轮选择基准数6，如图：

直到3，i、j相遇，说明此次“探测”结束，交换3和基准数6，

到此，第一轮快速排序结束。同理，继续分别处理基准数左边和右边的。

• 快速排序之所以比较快，是因为相比冒泡排序，每次交换是跳跃式的。其实快速排序是基于一种叫做“二分”的思想。
• 快速排序的最差的时间复杂度是$O(N^2)$
• 快速排序平均时间复杂度是$O(Nlog(N))$

def quick_sort(L,left,right):
	if left >= right:
		return L
	key = L[left]
	low = left
	high = right
	while left < right:
		while left < right and L[right] >= key:
			right -= 1
		L[left] = L[right]
		while left < right and L[left] <= key:
			left += 1
		L[right] = L[left]
	L[right] = key
	quick_sort(L, low, left-1)
	quick_sort(L, left+1, high)
	return L

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17