Python常用排序算法

 #快排 
 1 def q_sort(l):
    left = 0
    right = len(l)-1
    return q(l,left,right)

def quick_sort(l,left,right):
    if left >= right:
        return l
    low = left
    high = right
    while right>left:
        while right>left and l[right] >= l[left]:
            right -=1
        l[right],l[left] = l[left],l[right]
        while right>left and l[right] >= l[left]:
            left += 1
        l[right],l[left] = l[left],l[right]
    q(l,low,left-1)
    q(l,left+1,high)
    return l

 #堆排序
 1 def heap_sort(l):
    n = len(l)                #  n-1 最后一个节点标号
    first = (n/2-1)    #最后一个非叶子节点
    for start in range(first,-1,-1):     
        max_heap(l,start,n-1)

    for end in range(n-1,0,-1):
        l[end],l[0] = l[0],l[end]
        max_heap(l,0,end-1)         #去除最后一个节点 标号往前重构
    return l


def max_heap(l,start,end):
    root = start
    while True:
        child = root*2 + 1
        if child > end:break
        if child+1 <= end and l[child] < l[child+1]:
            child += 1
        if l[root] < l[child] :
            l[root],l[child] = l[child],l[root]
            root = child
        else:
            break

 #堆排序取前100大
 1 def heap_sort(l):
    n = len(l)
    first = n/2-1        # 最后一个非叶子节点
    for start in range(first,-1,-1):
        min_heap(l,start,n-1)

    for end in range(n-1,0,-1):
        l[end] ,l[0] = l[0] , l[end]
        min_heap(l,0,end-1)
    return l


def min_heap(l,start,end):
    root = start
    while 1:
        child = root*2+1
        if child > end :break
        if child+1 <= end and l[child] > l[child+1]:
            child+=1
        if l[root] > l[child]:
            l[root],l[child] = l[child],l[root]
            root = child
        else:
            break

def qu(x):　　　　　　　　　　#x为传入数列,z为输出前100的列表
    z = heap_sort(x[:100])
    print 'z:',z
    for i in x[100:]:
        if i > z[99]:
            z[99]=i
            heap_sort(z)
    return z

 #归并排序
 1 def merge_sort(l):
    if len(l) <= 1:
        return l
    num = len(l)/2
    left = merge_sort(l[:num])
    right = merge_sort(l[num:])
    return merge(left,right)

def merge(left,right):
    i=j=0
    r=[]
    while i<len(left) and j<len(right):
        if left[i] <= right[j]:
            r.append(left[i])
            i+=1
        else:
            r.append(right[j])
            j+=1
    r += left[i:]
    r += right[j:]
    return r

#冒泡
def maopao(seq):
    for i in range(0,len(seq)-1):
        for j in range(0,len(seq)-1-i):
            if seq[j] > seq[j+1]:
                seq[j],seq[j+1]=seq[j+1],seq[j]
    return seq    

#插入
def DirectInsert(seq):
    for i in range(1,len(seq)):
        temp, j = seq[i], i
        while j>0 and temp < seq[j-1]:
            seq[j] = seq[j-1]
            j = j-1
        seq[j] = temp
    return seq

#插入(从中间开始)
def DI(seq):
    for i in range(1,len(seq)):
        temp, j,k = seq[i], i, i/2
        if temp < seq[k]:
            while k>0 and temp < seq[k-1]:
                seq[k] = seq[k-1]
                k = k-1
            seq[k] = temp
        else:
            while j>0 and temp < seq[j-1]:
                seq[j] = seq[j-1]
                j = j-1
            seq[j] = temp
    return seq

#直接选择排序
def select_sort(l):
    for i in range(0,len(l)):
        min = i
        for j in range(i+1,len(l)):
            if l[min] > l[j]:
                min = j
        l[min],l[i] = l[i],l[min]
    return l

参考:http://www.cnblogs.com/jztan/p/5878630.html