python-排序算法

k = [1,34,3,2,54,56,3,31,67,9,5,0,10]
#冒泡
def orders(k): 
    leng = len(k)
    flag = True
    i = 0
    while i < leng and flag:
        j = leng - 1
        flag = False
        while j > i:
            if k[j] < k[j-1]:
                k[j],k[j-1] = k[j-1],k[j]
                flag = True
            j -= 1
        i += 1
    return k

#print orders(k)
#选择
def selects(k):
    lengs = len(k)
    i  = 0
    flag = True
    while i < lengs:
        mins = i
        j = i + 1
        while j <=  lengs - 1:
            if k[mins] > k[j]:
                mins = j
                #flag = True
            j += 1
        if mins != i:
            k[mins],k[i] = k[i],k[mins]
        i += 1
    return k
#print selects(k) 

#插入
def inputs(k):
    print k
    lengs = len(k)
    i = 0
    while  i < lengs:
        if k[i] < k[i-1]:
            m = k[i]
            j = i - 1
            while j >= 0 and k[j] > m:
                k[j+1] = k[j]
                j -= 1
            k[j+1] = m
        
        i += 1
    return  k
#print  inputs(k)

#希尔
#[1, 34, 3, 2, 54, 56, 3, 31, 67, 9, 5, 0, 10]
def hashs(k):
    lens= int(len(k))
    incr = lens
    while incr > 1:
        incr = incr/3 + 1
        i = incr
        while i <  lens:
            if k[i] < k[i - incr]:
                tmp = k[i]
                j = i - incr
                while j >= 0 and tmp < k[j]:
                    k[j+incr] = k[j] 
                    j -= incr
                k[j+incr]  = tmp
            i += 1
        
    print k
#print k
#hashs(k)
#堆
def __heapA(k,index,l):
    lag = index
    left = 2*index +1
    right = left+1
    if left < l and k[lag] < k[left]:
            lag = left
    if right < l and k[lag] < k[right]:
            lag = right
    if lag != index:
        k[lag],k[index]  = k[index],k[lag]
        __heapA(k,lag,l)
                    
def heap(k):
    lens = len(k) 
    i = lens/2
    while i >= 0:
        __heapA(k,i,lens)
        i -= 1
    i = lens - 1
    while i > 0:
        k[0],k[i] = k[i],k[0]
        __heapA(k,0,i)
        i -= 1
    return k
#print heap(k)
    
    

#归并
def merge(lef,rig):
    result = []
    i,j = 0,0
    while i < len(lef) and j < len(rig):
        if lef[i] <= rig[j]:
            result.append(lef[i])
            i += 1
        else:
            result.append(rig[j])
            j += 1
    result += lef[i:]
    result += rig[j:]
    return result
def reduces(k):
    if len(k) <= 1:
        return k
    m = int(len(k) / 2)
    lef = reduces(k[:m])
    rig = reduces(k[m:])
    return merge(lef,rig)
#print reduces(k)
        

                
#快速

def __change(k,start,end):
    pro = k[start]
    while start < end:
        while start < end and k[end] >= pro:
            end -= 1
        k[end],k[start] = k[start],k[end]
        
        while start < end and k[start] <= pro:
            start += 1
        k[start],k[end] = k[end],k[start]
    return start

def qu(k,start,end):
    if start < end:
        pro = __change(k,start,end)
        #print  pro
        qu(k,start,pro)
        qu(k,pro+1,end)
    print k

#qu(k,0,len(k) - 1)