算法导论——python实践（2.简单排序算法）

2.1简单排序算法

#  插入排序

#类比打牌的时候手牌的插入排序
a=[1,4,6,3,7,8,9,543,2,6,78,90,54]
for j in range(1,len(a)):
	key=a[j]
	i=j-1
	while (i>=0 and a[i]>key):
		a[i+1]=a[i]
		i=i-1
	a[i+1]=key
print (a)

#选择排序

#  选择算法
#找出a中最小的数，与a中第一个数交换，然后找出第二小的数，与a中第二个数交换
a=[124,4,6,3,7,8,9,543,2,6,78,90,54]
for i in range(0,len(a)):
	key=a[i]
	for j in range(i+1,len(a)):
		if a[j]<key:
			key=a[j]
			k=j
	a[k]=a[i]
	a[i]=key
print (a)

#冒泡排序算法

沉底排序与选择排序不同的是，选择排序是找出最小值，沉底排序是一次交换相邻的元素，使得最小值沉入列表底端。

#  沉底排序
#i固定时，a[i]中始终存储较小的数值，第一轮比较完a[0]中为最小值2，
#以此类推，a[1]中为次小值
a=[124,4,6,3,7,8,9,543,2,6,78,90,54]
for i in range(0,len(a)):
    for j in range(i+1,len(a)):
        if a[j]<a[i]:
            a[i],a[j]=a[j],a[i]     
print (a)

#冒泡排序
a=[124,4,6,3,7,8,9,543,2,6,78,90,54]
for i in range(0,len(a)):
    for j in range(len(a)-1,i,-1):
        if a[j]<a[j-1]:
            a[j],a[j-1]=a[j-1],a[j]
print (a)

  冒泡排序算法过程：交换相邻的元素，使得右边的元素始终比左边大，第一轮比较完，最小的数2沉底，较大的数浮上来，以此类推，每一轮结束，都有一个极小值沉底，相应的大值浮上来，最后一轮，最大值在顶层。故命名为冒泡法。

2.2 分治法（类似递归法）

  将原问题分解为几个规模较小但类似于原问题的子问题，递归的求解这些子问题，
然后再合并这些子问题的解来建立原问题的解。

import math
def merge(left, right):#两组序列的排序合并
    result = []
    i = 0
    j = 0
    while i < len(left) and j < len(right):
        if left[i] <= right[j]:
            result.append(left[i])
            i += 1
        else:
            result.append(right[j])
            j += 1
    result += left[i:]
    result += right[j:]
    return result
def mergesort(seq):  #拆分序列
    if len(seq) <= 1:
        return seq
    mid =math.floor(len(seq)/2)
    left = mergesort(seq[:mid])
    right = mergesort(seq[mid:])
    return merge(left, right)

seq=[124,4,6,3,7,8,9,543,2,6,78,90,54]
print ('原序列：',seq)
result = mergesort(seq)
print ('排序后序列：',result)

递归问题的最重要的一点是：注明递归结束出口，这里设置到如果列表中只有一个元素时，返回该元素。

通过pycharm调试，mergesort函数将列表拆分到只有一个元素的时候，开始进行两个元素的归并工作，其次类推，随后进行两组列表的归并工作。

参考文献：

【1】算法导论（第三版）第二章，机械工业出版社