排序

插入排序包括直接插入排序和希尔排序

选择排序包括直接选择排序和推排序

交叉排序包括冒泡排序和快排

本文用python实现了插入、希尔、直接选择、堆、冒泡、归并、基排序

http://python.jobbole.com/82270/

# coding=utf-8


# 1.插入排序，插入排序就是每一步都将一个待排数据按其大小插入到已经排序的数据中的适当位置，直到全部插入完毕--O（n）
def insert_sort(list):
    count=len(list)
    for i in range(1,count):
        key=list[i]#将待排序的数设成key
        j=i-1#和i之前的数进行比较
        while j>=0:
            if list[j]>key:
                list[j+1]=list[j]
                list[j]=key
            j-=1
    return list


#2.希尔排序：两个数以gap的距离依次比较，gap=n/2，gap=gap/2
def shell_sort(list):
    count=len(list)
    gap=count//2
    while gap>0:
        for i in range(0,gap):#i为外循环
            j=i+gap            #此为插入排序，
            while j<count:
                k=j-gap
                key=list[j]
                while k>0:
                    if list[k]>key:
                        list[k+gap]=list[k]
                        list[k]=key
                    k-=gap
                j+gap
        gap//=2
        return list

#3.冒泡排序--两个相邻数两两进行比较，外循环一次就能确定一个位置--O（n*n）
def bubble_sort(list):
    n=len(list)
    for i in range(0,n):
            for j in range(0,n-i):
                if list[j]>list[j+1]:
                    list[j],list[j+1]=list[j+1],list[j]
               
            
    return list

#4.选择排序--第一个数据和后面的所有数据比较
def select_sort(list):
    n=len(list)
    for i in range(0,n):
        for j in range(i+1,n):
            if list[i]>list[j]:
                list[i],list[j]=list[j],list[i]
            
   
    return list
#选择排序方法2
def select2_sort(list):
    n=len(list)
    for i in range(0,n):
        min=i
        for j in range(i+1,n):#循环结束之后找出j 对应的最小值
            if list[min]>list[i]:
                min=j
        list[min],list[i]=list[i],list[min]
    return list
#4.快速排序--O（nlogn)--分治思想;1.找一个基准2.循环一次后小数在基准左边，大数在基准右边3.重复步骤2，时间复杂度：O（lgn）--O（n）
def quick_sort(list,l,r):
    if l>=r:
        return list

    i=l
    j=r
    key = list[i]
    while i<j:
        while i<j and list[j]>=key:
            j-=1
        
        while i<j and list[i]<=key:
            i+=1
        if i<j:
            list[i],list[j]=list[j],list[i]
   list[l],list[i]=list[i],key
   quick_sort(list,l,i-1)
    quick_sort(list,i+1,r)
    return list
#5.归并排序的最好，最坏，平均时间复杂度均为O(nlogn)。
# coding=utf-8
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:]#left\right中可能剩余，把剩余的加入result数组中
    return result
def mergesort(lists):
    if len(lists)<=1:
        return lists
    num=len(lists)/2
    left=mergesort(lists[:num])
    right=mergesort(lists[num:])
    return merge(left,right)

if __name__ == '__main__':
    lists = [1, 4, 3, 6, 5, 0]
    print mergesort(lists)




 #6.堆排序--利用堆结构排序，最大堆就是顶端值最大值,堆存贮类似分层遍历,排序类似选择排序建堆的时间复杂度是O（n）,调整堆的时间复杂度是lgn，所以堆排序的时间复杂度是O（nlgn）
# coding=utf-8
def build(list,size):
    for i in range((size-2)//2,-1,-1):
        adjust(list,i,size)

def adjust(list,root,size):
    max=root
    if root<size//2:
        lchild = 2 * root + 1
        rchild = 2 * root + 2
        if lchild < size and list[lchild] > list[max]:
            max = lchild
        if rchild < size and list[rchild] > list[max]:
            max = rchild
        if max != root:
            list[max], list[root] = list[root], list[max]
            adjust(list, max, size)
def duisort(list):#堆排序，建立最大堆，将第一个最大的数和最后一个数交换，0到倒数第一之前的
                            调整成最大堆， 再把第一个最大数与倒数第二的数交换再调整
    size = len(list)    build(list,size)    for i in range(size-1,-1,-1):        list[0],list[i]=list[i],list[0]        adjust(list,0,i-1)    return listif __name__ == '__main__':    lists=[27,23,13,80,3,16]    duisort(lists)    print lists
if __name__ == '__main__':    list=['3','4','1','0','9']   # print(insert_sort(list))    #print(shell_sort(list))   # print(bubble_sort(list))    print(select_sort(list))    print(select2_sort(list))    print(quick_sort(list,0,4))    print(dui_sort(list))