Python算法学习

把教材《算法设计与分析》的C/C++理解并翻译成python
练习python+算法

冒泡排序算法

从小到大排序

def bubble_sort(lists):
    count=len(lists)
    # i=0，1，……，count-2
    for i in range(0,count-1):
        for j in range(0,count-i-1):
            if lists[j]>lists[j+1]:
            # 这一轮下来后，lists[count-i-1]就会是这次排序中遇到的最大的数，所以第一次外循环时，数组的最后一个数就是数组中最大的数
                lists[j],lists[j+1]=lists[j+1],lists[j]     
    return lists

lists=[22,55,84,21,2,4,100]
lists=bubble_sort(lists)
print lists

合并算法

将两个有序的子数组a,b,合并为一个有序的数组new

def merge(a,b):
    new = []
    m,n=0,0
    while m<len(a) and n<len(b):
        if a[m]<b[n]:
            new.append(a[m])
            m +=1
        else:
            new.append(b[n])
            n +=1

    if m<len(a):
        for num in range(m,len(a)):
            new.append(a[num])
    else:
        for num in range(n,len(b)):
            new.append(b[num])
    return new

if __name__=='__main__':
    la=[1,3,5,7,9]
    lb=[0,2,4,6,8,10,11,12]
    print(merge(la,lb))
# 输出结果：
# [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]

插入排序算法

首先判断数组中最前面的两个元素，并使它们按照递增顺序排序；然后把第3个元素与前两个元素一次进行比较，并把它放在合适的位置，使得前面3个元素是有序的；接下来第4，第5，……直到第n个元素与前面n-1个元素一次进行比较，把它放在合适的位置，这样就成为一个有序的数组了

# 参考
def insert_sort(lists):
    # 从小到大排序
    count = len(lists)
    for i in range(1, count):
        key = lists[i]
        j = i - 1
        while j >= 0:
            if lists[j] > key:
                lists[j + 1] = lists[j]
                lists[j] = key
            j -= 1
    return lists

lists=[10,5,12,6,8]
print insert_sort(lists)

或者

def insert_sort(lists):
    # 从小到大
    for i in range(1,len(lists)):
        key=lists[i]
        for j in range(0,i):
            if lists[j]>key:
                # 开始往后挪
                k=i
                while k>=j:
                    lists[k]=lists[k-1]
                    k-=1
                lists[j]=key
# 注意这里要有一个break，不然明明已经比较并放在正确位置后会继续比较一次，然后就会有一个数不见了
                break
    return lists

lists=[10,5,12,6,8,2,88,20]
print insert_sort(lists)

二分查找法（二叉检索法）

给定一个有序的元素列表和一个数，查找该数在这个有序列表中的位置，使用二分查找每次可以排除一半的元素

# O(log n) 
def binary_search(list,item):
    low=0
    high=len(list)-1

    while low<=high:      #只要范围没有缩小到只剩一个元素
        mid=(low+high)/2
        guess=list[mid]
        if guess==item:
            return mid
        if guess > item:
            high=mid-1
        if guess < item:
            low=mid+1
    return None

#测试一下
mylist=[1,3,5,7,9]
print binary_search(mylist,3)
print binary_search(mylist,-1)
# 输出：
#   1
#   None

汉诺塔问题（递归）

将a柱子上的圆盘按一定规则借助b柱子完美地复制到c柱子上。规则：每次移动一个盘子，且只能让小的放在大的上面
算法思路：①先用c柱子作为辅助，递归调用本算法，把a最上面的n-1个圆盘移到b柱子；②再把下面的一片圆盘从a移动到c；③最后再用a作为辅助，递归调用本算法，把n-1片圆盘从b移到c。

# -*- coding: utf-8 -*-
def move(n,a,b,c):
    if n==1:
        print('将%s上的%s从%s->%s'%(a,n,a,c))
    else:
    # ①=》②=》③
        move(n-1,a,c,b)     
        print('将%s上的%s从%s->%s'%(a,n,a,c)) 
        move(n-1,b,a,c)  
#测试
move(4,'A','B','C')

好久之前写的，有点乱
参考：http://python.jobbole.com/82270/