常用的算法

1冒泡排序，复杂度O(n²)最慢，效率最低

临近的数字两两进行比较,按照从小到大或者从大到小的顺序进行交换,

这样一趟过去后,最大或最小的数字被交换到了最后一位,

然后再从头开始进行两两比较交换,直到倒数第二位时结束，以此类推比较第i次。。。

list=[6,3,4,8,1,10]
for i in range(len(list)):
    for j in range(1,len(list)-i):
        print i,j,list[j-1],list[j]
        if list[j-1] > list[j]:
            list[j-1],list[j]=list[j],list[j-1]     
        print list
print list

2选择排序，复杂度O(n²)

每次遍历选择一个最值，和冒泡的区别在于交换的是位置，也就是脚标

3插入排序复杂度O(n²)

插入排序通过把序列中的值插入一个已经排序好的序列中，直到该序列的结束。插入排序是对冒泡排序的改进。它比冒泡排序快2倍。一般不用在数据大于1000的场合下使用插入排序，或者重复排序超过200数据项的序列。

4快速排序，复杂度O(nlogn) 

对冒泡排序的改进，选出一个值，其他的数和这个值比较，比这个值小的都放在左边，比这个值大的都放在右边

（1） 如果不多于1个数据，直接返回。
（2） 一般选择序列最左边的值作为支点数据。
（3） 将序列分成2部分，一部分都大于支点数据，另外一部分都小于支点数据。
（4） 对两边利用递归排序数列（算是很快的排序算法了，因为递归，所以耗内存）

def quickSort(L, low, high):
    i = low 
    j = high
    if i >= j:
        return L
    key = L[i]
    while i < j:
        while i < j and L[j] >= key:
            j = j-1                                                             
        L[i] = L[j]
        while i < j and L[i] <= key:    
            i = i+1 
        L[j] = L[i]
    L[i] = key 
    quickSort(L, low, i-1)
    quickSort(L, j+1, high)
    return L
L=[12, 6, 9, 7, 5, 11, 4, 8, 3, 10]
print quickSort(L, 0, 9)
#i=0,j=len(L)-1

5堆排序复杂度O(nlogn) 

堆排序适合于数据量非常大的场合（百万数据）。

堆排序不需要大量的递归或者多维的暂存数组。这对于数据量非常巨大的序列是合适的。比如超过数百万条记录，因为快速排序，归并排序都使用递归来设计算法，在数据量非常大的时候，可能会发生堆栈溢出错误。

堆排序会将所有的数据建成一个堆，最大的数据在堆顶，然后将堆顶数据和序列的最后一个数据交换。接下来再次重建堆，交换数据，依次下去，就可以排序所有的数据。