python写排序算法

对于各类排序算法的介绍，在这里就不在阐述了，推荐下面这篇博客，看完排序的概念应该可以完全理解
http://www.cnblogs.com/eniac12/p/5329396.html

冒泡排序

传统排序

def bubbleSort(list):
    for i in range(len(list)-1):
        for j in range(len(list)-1-i):
            if( list[j]>list[j+1]):
                list[j],list[j+1] = list[j+1],list[j]

加标志位冒泡排序

def bubbleSortUpdate(list):
    for i in range(len(list)-1):
        flag = True
        for j in range(len(list)-1-i):
            if( list[j]>list[j+1]):
                flag = False
                list[j],list[j+1] = list[j+1],list[j]
        if flag is True:
            break

双向冒泡排序

def bubbleSort2(list):
    left = 0
    right = len(list)-1
    while(left<right):
        for i in range(left,right):
            if(list[i] > list[i+1]):
                list[i],list[i+1]=list[i+1],list[i]
        right-=1

        for j in range(right,left,-1):
            if(list[j-1] > list[j]):
                list[j-1],list[j] = list[j],list[j-1]
        left+=1

选择排序

def selectSort(list):
    for i in range(len(list)-1):
        minindex = i
        for j in range(i+1,len(list)):
            if list[j] < list[minindex]:
                minindex = j
        if minindex != i:
            list[i],list[minindex] = list[minindex],list[i]

插入排序

传统排序

def insertSort(list):
    for i in range(1,len(list)):
        temp = list[i]
        j = i-1
        while j>=0 and list[j]>temp:
            list[j+1]=list[j]
            j-=1
        list[j+1] = temp

二分插入排序

def binInsertSort(list):
    for i in range(1, len(list)):
        temp=list[i]
        left=0
        right=i-1
        while(left<=right):
            mid=(left+right)/2
            if(list[mid]>temp):
                right=mid-1
            else:
                left=mid+1
        # 后半段右移
        for t in range(i-1,left-1,-1):
            list[t+1]=list[t]
        list[left] = temp

归并排序

def mergeSort(list):
    if len(list)<=1:
        return list
    mid=len(list)/2
    leftlist=mergeSort(list[:mid])
    rightlist=mergeSort(list[mid:])
    return merge(leftlist,rightlist)

def merge(leftlist,rightlist):
    newlist=[]
    i=0
    j=0
    while i<len(leftlist) and j<len(rightlist):
        if(leftlist[i]<=rightlist[j]):
            newlist.append(leftlist[i])
            i+=1
        else:
            newlist.append(rightlist[j])
            j+=1

    newlist+=leftlist[i:]
    newlist+=rightlist[j:]
    return newlist

快速排序

def quickSort(list,left,right):
    if(left<right):
        l = left
        r = right
        temp = list[l]
        while l<r:
            while l<r and list[r]>=temp:
                r-=1
            if l<r:
                list[l]=list[r]
                l+=1
            while l<r and list[l]<temp:
                l+=1
            if l<r:
                list[r]=list[l]
                r-=1

        list[l] = temp
        quickSort(list,0,l-1)
        quickSort(list,l+1,right)

堆排序

def heapModify(list,index,len):
    left = 2*index+1
    right = 2*index+2
    max = index
    if left < len and list[left] > list[max]:
        max = left
    if right < len and list[right] > list[max]:
        max = right
    if max != index:
        list[index],list[max] = list[max],list[index]
        heapModify(list,max,len)
# 建堆
def buildheap(list,len):
    index = len / 2 - 1
    while index >= 0:
        heapModify(list,index,len)
        index-=1

def heapSort(list):
    # 建堆
    heapSize = len(list)-1
    buildheap(list,heapSize)
    # 堆排序，根和最后一个节点交换
    while heapSize>1:
        list[heapSize],list[0]=list[0],list[heapSize]
        heapSize -= 1
        heapModify(list,0,heapSize)