python写希尔、堆、快速、归并排序

1 希尔排序：

def shell_sort(seq):
	gap = len(seq)/2 # 以gap为间隙，将数组分成gap组，0 到gap-1分属不同的组
	#pdb.set_trace()
	while gap > 0: # gap最小为1
		for i in range(0, gap): # 0 到 gap-1组，分别用直接插入排序处理每组，取得每组的第一个元素i
			for j in range(i+gap, len(seq), gap): # 确定这一组的若干元素，从第二个元素开始取待插入元素
				for k in range(i, j, gap): # 待插入元素与前面元素做对比，从第一个元素比起
					if seq[j] < seq[k]:
						tmp = seq[j]
						seq.pop(j)
						seq.insert(k, tmp)
		gap /=2

2 堆排序：

def heap_adjust(seq, end, mid):  # 建立大顶堆，end是尾元素下标，mid为中间位置元素
	#pdb.set_trace()
	for i in range(mid, -1, -1):# 堆，或者二叉树顺序存储结构的特性有：第i个元素的左右子节点为i*2+1和i*2+2，从中间位置元素开始往前，分别进行置换
		if i*2+1 > end: # 没有子节点
			continue
		if i*2+1 == end: # 有左子结点
			if seq[i] < seq[i*2+1]:
				seq[i], seq[i*2+1] = seq[i*2+1], seq[i]
		else:	# 有左右子节点，找到最小的赋予i位置
			if seq[i*2+1] < seq[i*2+2]:
				seq[i*2+1],seq[i*2+2] = seq[i*2+2],seq[i*2+1]
			if seq[i] < seq[i*2+1]:
				seq[i],seq[i*2+1] = seq[i*2+1], seq[i]

def heap_sort(seq):	# n个元素的大顶堆建立后，堆的首尾元素互换，n-1个元素重新建立大顶堆
	for i in range(len(seq)-1, 0, -1):
		mid = i/2
		heap_adjust(seq, i, mid)
		seq[0],seq[i] = seq[i], seq[0]

3 快速排序：

def median(seq, start, center, end): #put median number at start，将中值放在start位置，避免快排最坏情况出现
	if seq[start] > seq[end]:
		seq[start], seq[end] = seq[end], seq[start]
	if seq[start] > seq[center]:
		seq[start], seq[center] = seq[center], seq[start]
	if seq[center] > seq[end]:
		seq[start], seq[end] = seq[end], seq[start]
	else:
		seq[start], seq[center] = seq[center], seq[start]

def quik_sort(seq, start, end):
	if start >= end:				#终止条件
		return

	mid = (start + end)/2	
	median(seq, start, mid, end)	# 设定中值
	key = seq[start]
	lp = start # 左侧游标
	rp = end   # 右侧游标

	while True: # 进行一轮移动，移动结果为将start位置的中值移动到某位，其左侧都小于中值，右侧都大于中值
		while key < seq[rp] and rp > lp: # 从右侧游标开始比较并移动rp
			rp = rp - 1
		if rp > lp:
			seq[lp] = seq[rp] # 将右侧游标数据放到左侧游标位置
			lp = lp + 1 # 左侧游标前移，指向下一个待比较数据
		while key > seq[lp] and lp < rp: # 从左侧游标开始比较并移动lp
			lp = lp +1 
		if lp < rp:
			seq[rp] = seq[lp] # 将左侧游标数据放到右侧游标位置
			rp = rp -1 # 右侧游标前移，指向下一个待比较数据
		if lp >= rp: # 如果lp和rp会和，则终止循环
			break

	seq[lp] = key # 此时的lp指向中值应该放置的位置
	quik_sort(seq, start, rp-1)				# 分成两段进行分治
	quik_sort(seq, rp+1, end)

4. 归并排序

def merge_array(seq, start, mid, end):
	#pdb.set_trace()
	part_1 = seq[start:mid+1]
	part_2 = seq[mid+1:end+1]
	i = 0
	j = 0
	k = start
	while (i < len(part_1)) and (j < len(part_2)): 
		if part_1[i] < part_2[j]:
			seq[k] = part_1[i]
			i += 1
			k += 1
		else:
			seq[k] = part_2[j]
			j += 1
			k += 1

	for index in range(i, len(part_1)):
		seq[k] = part_1[index]
		k += 1

	for index in range(j, len(part_2)):
		seq[k] = part_2[index]
		k += 1

def merge_sort(seq, start, end):
	if end == start:
		return
	mid = (start + end)/2
	merge_sort(seq, start, mid)
	merge_sort(seq, mid+1, end)
	merge_array(seq, start, mid, end)