转自：http://www.cnblogs.com/cnkai/p/7642766.html

递归：递归的数学模型其实就是归纳法

函数名的_和__的含义：

1、

冒泡排序

算法思想：

对于一组需要排序的数据，对于相邻的两个数进行比较，使较大（或者较小）的数一直向后推，经过多层排序之后，使整个序列是有序的。

算法实现：

def bubble_sort(L):
    length = len(L)
    if length == 0 or length == 1:
        return L
    for i in range(length):#2,3,4,1,7,5,6,8 一共8个数，需要8趟，i(0-7)
        for j in range(length-i-1):#第i趟之后，都会沉淀i个数,第一趟开始，j=0,需取[0~6]，最后比较j=6,j+1=7,即比较len(L)-1次。
            if L[j] > L[j+1]:
                temp = L[j]
                L[j] = L[j+1]
                L[j+1] = temp
    return L
data=[7,2,3,6,5,4,1,0]
print(bubble_sort(data))

运行结果为：

算法的实现使用了两层for循环，其中对于外层for循环来说，第一次for循环，最大的数被推到最后面，第二次for循环，次大的数被推到次后面…依次类推，而内层for循环的作用就是实现将当前层次的最大数找出来，向后沉。

复杂度：

• 时间复杂度
  平均情况O(n^2)， 最好情况O(n)， 最坏情况O(n^2)
• 空间复杂度
  O(1)
• 稳定性
  稳定

2、

快速排序

算法思想：

任意设置一个基准元素，一般是第一个或者最后一个，将序列以该基准元素为基准，分割成比他小的一部分和比他大的一部分，此时，该基准元素所在的位置就是排序终了之后的准确位置，在对左右两边的序列继续执行同样的操作，直整个个序列有序。

算法实现：

def quick_sort(lists,left,right):
    if left>=right:
        return lists
    key=lists[left]
    low=left
    high=right
    while left<right:#当左右下标不等时，
        while left <right and lists[right]>=key:#当左右下标不等，并且右边的值大于基准时，右边的下标向前移
            right-=1
        lists[left]=lists[right]#把右边小的放到左边
        while left <right and lists[left]<=key:#当左右下标不等，并且左边的值小于基准时，左边的下标向前移
            left+=1
        lists[right]=lists[left]#把左边大的放到右边
    lists[right]=key#当左右坐标相等时。
    print(lists)
    quick_sort(lists,low,left-1)
    quick_sort(lists,left+1,high)
    return lists
data=[7,2,3,6,5,4,1,0]
print(data)
print(quick_sort(data,0,len(data)-1))
#原数据：[7,2,3,6,5,4,1,0]
#第一趟：[0,2,3,6,5,4,1,7]#此时left已经到index=7的位置，quick_sort(lists,0,7-1)
#第二趟：[0,2,3,6,5,4,1,7]#quick_sort(lists,0,0-1)，return lists
#第三趟：[0,1,2,6,5,4,3,7]#quick_sort(lists,0+1,6)
#


#原数据[7, 2, 3, 6, 5, 4, 1, 0]
#[0, 2, 3, 6, 5, 4, 1, 7]
#[0, 2, 3, 6, 5, 4, 1, 7]
#[0, 1, 2, 6, 5, 4, 3, 7]
#[0, 1, 2, 3, 5, 4, 6, 7]
#[0, 1, 2, 3, 5, 4, 6, 7]
#[0, 1, 2, 3, 4, 5, 6, 7]
#[0, 1, 2, 3, 4, 5, 6, 7]

运行结果：

内层的while循环中，以key为基准，从序列的右边找出比key值小的元素，放在key的左边去，再从key的左边找出比key值大的元素，放在key的右边，此时正好填补了放到左边的的那个空位，多次循环，直到序列有序。

复杂度：

• 时间复杂度
  平均情况O(nlog2n)， 最好情况O(nlog2n)， 最坏情况O(n^2)
• 空间复杂度
  O(nlog2n)
• 稳定性
  不稳定

选择排序

算法思想：

在需要排序的一组数中，选出最小（或者最大）的一个数与第一个位置的数交换，然后在剩下的数中在找到最小（或者最大）的数与第二个位置的数交换，一次类推，直到倒数第二个数与倒数第一个数交换完成为止。

算法实现：

def select_sort(L):
    length=len(L)
    if length==0 or length==1:
        return L
    def _min(s):
        '''
        实现从后面的值中找到最小值的索引
        '''
        min=s
        for i in range(s,length):
            if L[i]<L[min]:
                min=i
        return min
    for i in range(length):
        min=_min(i)
        print('min:%d'%min)
        if i!=min:
            temp=L[min]
            L[min]=L[i]
            L[i]=temp
        print(L)
    return L
data=[7,2,3,6,5,4,1,0]
print(data)

print(select_sort(data))

运行结果：

一次循环，都将该次循环的i作为基准，从i后面的数中通过_min()函数来找到后面数据最小值的索引，在for循环的循环体内交换位置，目的是将小值放到前面去。这样，每一次循环，数中最前面的一部分数据是从小到大排序的，直到最后，所有的数据都是有序的为止。

复杂度：

• 时间复杂度
  平均情况O(n^2)， 最好情况O(n^2)， 最坏情况O(n^2)
• 空间复杂度
  O(1)
• 稳定性
  不稳定

归并排序

算法思想：

主题思想是将两个有序表河滨更成为一个新的有序表，将待排序序列分位若干个子序列，每个子序列是有序的，然后在将其合并为一个整体，使用递归的思想。

算法实现：

运行结果为：

def merge(left,right):
    i,j=0,0
    result=[]
    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 merge_sort(lists):
    #归并排序
    if len(lists)<=1:
        return lists
    num=int(len(lists)/2)
    left=merge_sort(lists[:num])
    print("left")
    print(left)
    right=merge_sort(lists[num:])
    print("right")
    print(right)
    return merge(left,right)

data=[7,2,3,6,5,4,1,0]
print(data)
print(merge_sort(data))
                     

将一个序列一直对半拆分，分为若干个子序列，直到该子序列只有一个元素为止，然后将其合并。因此主要的问题就变成了如何将两个有序序列合并，这里新建一个空序列，遍历比较两个序列，将较小的元素放在新的序列中，直到某一个序列为空，此时很可能另外的一个序列非空，因此需要将剩余的已经有序的元素一次性添加到新建的序列中。

复杂度：

• 时间复杂度
  平均情况O(nlog2n)， 最好情况O(nlog2n)， 最坏情况O(nlog2n)
• 空间复杂度
  O(n)
• 稳定性

• 稳定

插入排序

算法思想：

将序列的第一个元素当做已经排序好的序列，然后从后面的第二个元素开始，逐个元素进行插入，直到整个序列有序为止。

算法实现：

def insert_sort(L):
    length=len(L)
    if length==0 or length==1:
        return L
    for i in range(1,length):
        value=L[i]
        j=i-1
        while j>=0 and L[j]>value:#看比较的那个值前面的所有值是不是都是排好的
            L[j+1]=L[j]
            j-=1
        L[j+1]=value
        print(L)
    return L

data=[7,2,3,6,5,4,1,0]
print("原数据")
print(data)
print(insert_sort(data))
#[2,3,7,6,5,4,1,0]

运行结果：

对于for循环来说，第一次循环结束，整个序列的第一个元素是有序的，第二次循环，前面两个元素是有序的，第三次for循环，前面三个元素是有序的…对于while循环来说，只要索引为i的前面某个元素比我们设置的“哨兵”value的值大，就把它放在后面去，直到前面所有的元素均比value小，这时候本次排序结束，本次排序的结果依然是有序的，因为上一次的结果是有序的，我们本次排序只是将一个新的值加入进去，并没有破坏之前的结构，因此将其称之为“插入排序”。

复杂度：

• 时间复杂度
  平均情况O(n^2)， 最好情况O(n)， 最坏情况O(n^2)
• 空间复杂度
  O(1)
• 稳定性
  稳定

希尔排序

算法思想：

希尔排序是对直接插入排序的改进版本，又称为缩小增量排序，将整个序列分割成若干个子序列，分别进行直接插入排序，待各个子序列基本语序后，在对全体进行直接插入排序。

算法实现：

def shell_sort(lists):
    count=len(lists)
    step=2
    group=int(count/step)
    while group>0:
        for i in range(group):
            j=i+group
            while j<count:
                key=lists[j]
                k=j-group
                while k>=0:
                    if lists[k]>key:
                        lists[k+group]=lists[k]
                        lists[k]=key
                    k=k-group
                j=j+group
        group=int(group/step)
    return lists
data=[7,2,3,6,5,4,1,0]
print(shell_sort(data))