python排序算法

-*- coding:UTF-8 -*-

if __name__=='__main__':

     lists=[3,46,6,3,6,46,8,3,15,2,30]

     print(lists)

     sortedLists=sorted(lists)

     print(sortedLists)

##--1.-冒泡排序

def bubble_sort(lists):

    le=len(lists)

    for i in range(le):

#---两两比较区间内的取值

        for j in range(i+1,le):

            if lists[i]>lists[j]:

                lists[i],lists[j]=lists[j],lists[i]

    return lists

if __name__=='__main__':

    lists=[3,46,6,3,6,46,8,3,15,2,30]

    print(lists)

    sortedLists=bubble_sort(lists)

    print(sortedLists)

##-----------------------------------------------------------------------------------

##-----2.-选择排序

def  select_sort(lists):

    le=len(lists)

###假设i为最小值的索引，

    for i in range(le):

        minIndex=i

        for j in range(i+1,le):

##寻找最小数并把最小数的索引保存           

            if lists[minIndex]>lists[j]:

                lists[minIndex],lists[j]=lists[j],lists[minIndex]

    return lists

if __name__=='__main__':

    lists=[3,46,6,3,6,46,8,3,15,2,30]

    print(lists)

    sortedLists=select_sort(lists)

    print(sortedLists)

##-----------------------------------------------------------------------------------

##3.--插入排序

def insert_sort(lists):

    le=len(lists)

    for i in range(le):

        preIndex=i-1

        current=lists[i]

##构建有序序列，对未排序的数据，在已排序的序列中从后向前扫描，插入相应位置       

        while preIndex>=0 and lists[preIndex]>current:

            lists[preIndex+1]=lists[preIndex]

            preIndex-=1

        lists[preIndex+1]=current

  

    return lists

if __name__=='__main__':

    lists=[3,46,6,3,6,46,8,3,15,2,30]

    print(lists)

    sortedLists=insert_sort(lists)

    print(sortedLists)

##-----------------------------------------------------------------------------------

##--4.--希尔排序

def shell_sort(lists):

    le=len(lists)

    gap=le//2

##----定义间隔序列至1（5，3，1）  

    while gap>0:

        for i in range(gap,le):

            j=i

            while j>=gap:

##----交换a[i]和a[i+gap]                

                if lists[j]<lists[j-gap]:

                    lists[j],lists[j-gap]=lists[j-gap],lists[j]

                    j-=gap

                else:

                    break

###-----重新定义间隔序列                   

        gap//=2

    return lists

if __name__=='__main__':

    lists=[3,46,6,3,6,46,8,3,15,2,30]

    print(lists)

    sortedLists=shell_sort(lists)

    print(sortedLists)

##-----------------------------------------------------------------------------------

##--------5- 快速排序

def quick_sort(lists, left, right):

    if left >= right:

        return lists

   

    key = lists[left]

    low = left

    high = right

##数据分割成两个独立的部分（左小右大），对left和right两部分进行排序   

    while left < right:

        while left < right and lists[right] >= key:

            right -= 1

        lists[left] = lists[right]

        while left < right and lists[left] <= key:

            left += 1

        lists[right] = lists[left]

    lists[right] = key

#递归快速排序   

    quick_sort(lists, low, left - 1)

    quick_sort(lists, left + 1, high)

    return lists

if __name__=='__main__':

    lists=[46,6,7,48,8,3,15,3,46,7,2,30]

    print(lists)

    sortedLists=quick_sort(lists,0,len(lists)-1)

    print(sortedLists)

##-----------------------------------------------------------------------------------

#---6.--堆排序

def heap_sort(array):

    def heap_adjust(parent):

        child = 2 * parent + 1 # left child

        while child < len(heap):

###找出左右孩子节点中较大的

            if child + 1 < len(heap):

                if heap[child + 1] > heap[child]:

                    child += 1 # right child

#判断是否为大顶堆                   

            if heap[parent] >= heap[child]:

                break

###子节点上移               

            heap[parent], heap[child] = heap[child], heap[parent]

##继续向下比较          

            parent, child = child, 2 * child + 1

##将原堆顶插入正确位置   

    heap, array = array.copy(), []

##建立大顶堆，最后一个非叶节点（完全二叉树中）

    for i in range(len(heap) // 2, -1, -1):

        heap_adjust(i)

    while len(heap) != 0:

#将大顶堆堆顶数放到最后，调整剩余数组成堆

        heap[0], heap[-1] = heap[-1], heap[0]

        array.insert(0, heap.pop())

        heap_adjust(0)

    return array

if __name__=='__main__':

    list1 = [46,6,7,48,8,3,15,3,46,7,2,30]

    print(list1)

    b=heap_sort(list1)

    print(b)

##-----------------------------------------------------------------------------------

#------7.---归并排序

##-----子序列排序--将两个有序表合并

def merge(left,right):

    i=0

    j=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:]

    return result

#----划分左右区间

def merge_sort(lsits):

    if len(lsits)<=1:

        return lsits

    num=int(len(lsits)/2)

    left=merge_sort(lsits[:num])

    right=merge_sort(lsits[num:])

    return merge(left,right)

if __name__=='__main__':

    list1 = [5, 6, 7, 4, 9, 11, 20, 1]

    print(list1)

    b=merge_sort(list1)

    print(b)

##-----------------------------------------------------------------------------------

#-----8.基数排序

def radix_sort(array):

    bucket, digit = [[]], 0

    while len(bucket[0]) != len(array):

        bucket = [[], [], [], [], [], [], [], [], [], []]

        for i in range(len(array)):

            num = (array[i] // 10 ** digit) % 10

            bucket[num].append(array[i])

        array.clear()

        for i in range(len(bucket)):

            array += bucket[i]

        digit += 1

    return array

if __name__=='__main__':

    list1 = [5, 6, 7, 4, 9, 11, 20, 1]

    print(list1)

    b=radix_sort(list1)

    print(b)

##-----------------------------------------------------------------------------------

##----9.-桶排序

def bucket_Sort(nums):

# 选择一个最大的数

    max_num=max(nums)

# 创建一个元素全是0的列表, 当做桶

    bucket=[0]*(max_num+1)

# 把所有元素放入桶中, 即把对应元素个数加一

    for i in nums:

         bucket[i]+=1

# 存储排序好的元素

    sort_nums=[]

# 取出桶中的元素

    for j in range(len(bucket)):

        if bucket[j]!=0:

            for y in range(bucket[j]):

                sort_nums.append(j)

    return sort_nums

if __name__=='__main__':

  

    list1 = [5, 6, 7,7,5,9,4, 9, 11, 20, 1]

    print(list1)

    b=bucket_Sort(list1)

    print(b)

##-----------------------------------------------------------------------------------

#-----10.-计数排序

def count_sort(lsits):

    n = len(lsits)

    res = [None] * n

    首次循环遍历, 每个列表的数都统计

    for i in range(n):

        p 表示 a[i] 大于列表其他数 的次数

        p = 0

        q 表示 等于 a[i] 的次数

        q = 0

        二次循环遍历, 列表中的每个数都和首次循环的数比较

        for j in range(n):

            if lsits[i] > lsits[j]:

                p += 1

            elif lsits[i] == lsits[j]:

                q += 1

        for k in range(p, p+q):  # q表示 相等的次数,就表示, 从 P 开始索引后, 连续 q 次,都是同样的 数

            res[k] = lsits[i]

    return res

if __name__=='__main__':

  

    list1 = [5, 6, 7,7,5,9,4, 9, 11, 20, 1]

    print(list1)

    b=count_sort(list1)

    print(b)

 

---------------

程序猿： https://www.itcodemonkey.com/

伯乐在线： http://python.jobbole.com/