经典排序算法python实现总结

# -*- coding: utf-8 -*-
''' 本代码是在python2.7下实现的，不同版本可以需要略加修改'''
'''
1。归并排序

'''
def MergeSort(lists):   #不断递归的二分自己，直到自己每个子项只有一个元素，再调用merge函数合并
    if len(lists) <= 1:
        return lists
    num=int(len(lists)/2)
    left=MergeSort(lists[:num])
    right=MergeSort(lists[num:])
    return Merge(left,right)

def Merge(left,right):      #把有序的左右两个序列合并
    l,r=0,0
    result=[]
    while l < len(left) and r < len(right):
        if left[l] <= right[r]:
            result.append(left[l])
            l+=1
        else:
            result.append(right[r])
            r+=1
    result += left[l:]
    result += right[r:]
    return result

# print(MergeSort([49, 38, 65, 97, 76, 13, 27, 49, 55, 4]))

'''
2.插入排序：把数据分成前后两部分，
第一部分代表有序数列起初只有一个数据，
把第二部分的数据依次插入第一部分插入后保证有序，
直到完成
时间复杂度为O(n^2)
'''
def Insertsort(lists):
    count = len(lists)
    for i in range(1, count):
        key = lists[i]
        j = i - 1
        while j >= 0:
            if lists[j] > key:
                lists[j + 1] = lists[j]
                lists[j] = key
            j -= 1
    return lists


# print(InsertSort([1,2,3,4,0,43,23,11]))
'''3.希尔排序又称缩小增量排序'''
def IncrementInsetSort(lists, dk):  # 给定增量的插入排序，即是希尔排序的一趟的结果
    count = len(lists)
    for i in range(dk, count):  # 从下标为dk的数进行插入排序
        key = lists[i]  # 要插入的数
        j = i - dk
        while j >= 0:
            if lists[j] > key:
                lists[j + dk] = lists[j]
                lists[j] = key
            j -= dk
    return lists


# print(IncrementInsetSort([49, 38, 65, 97, 76, 13, 27, 49, 55, 4], 5))
# 希尔排序
def ShellSort(lists):  # 希尔排序
    dk = int(len(lists)/2)  # 增量
    while(dk >= 1):
        IncrementInsetSort(lists,dk)
        print("增量dk=%d>>%s:"%(dk, lists))
        dk = int(dk/2)
    return lists

# print(ShellSort([49, 38, 65, 97, 76, 13, 27, 49, 55, 4]))
'''
4.冒泡排序
i表示趟数，j代表要比较的元素的下标
前后两个元素相比较，如果他们的顺序错误就把他们交换过来。
'''
def BubbleSort(lists):
    count=len(lists)
    for i in range(count):
        for j in range(count-1):
            if lists[j]>lists[j+1]:
                lists[j],lists[j+1]=lists[j+1],lists[j]
    return lists

# print(BubbleSort([49, 38, 65, 97, 76, 13, 27, 49, 55, 4]))

'''
5.快速排序（Quicksort）是对冒泡排序的一种改进
通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，
然后再按此方法对这两部分数据分别进行快速排序，
整个排序过程可以递归进行，以此达到整个数据变成有序序列。
'''
def QuickSort(lists,low,hight):
    if low >= hight:
        return lists
    left=low                                        #left代表位于key左边的指针
    right=hight                                     #right代表位于key右边的指针
    key=lists[left]
    while left < right:
        while left<right and lists[right] >= key:   #右边数据比key大，光标左移
            right -= 1
        lists[left] = lists[right]                   #右边数据比key小，数据移动到左边
        while left<right and  lists[left] <= key:   #左边数据比key小，光标右移
            left+=1
        lists[right] = lists[left]                   #左边数据比key大，数据移动到右边
    lists[left] = key                                #枢轴记录到位
    QuickSort(lists,low,left-1)
    QuickSort(lists,left+1,hight)
    return lists

# print(QuickSort([49, 38, 65, 97, 76, 13, 27, 49, 55, 4],0,9))
'''
6.每次次选出最小的元素，再依次与前面的0，1，2...上的元素进行交换
'''
def SelectSort(lists):
    count=len(lists)
    for i in range(count):
        min=i
        for j in range(i+1,count):
            if lists[min] > lists[j]:
                min=j
            lists[min],lists[i] = lists[i],lists[min]
    return lists

# print(SelectSort([49, 38, 65, 97, 76, 13, 27, 49, 55, 4]))


'''堆排序
7.时间复杂度O（nlogn）
'''

def AdjuHeap(lists, i, size):
    lchild = 2 * i + 1
    rchild = 2 * i + 2
    max = i
    if i < size / 2:
        if lchild < size and lists[lchild] > lists[max]:
            max = lchild
        if rchild < size and lists[rchild] > lists[max]:
            max = rchild
        if max != i:
            lists[max], lists[i] = lists[i], lists[max]
            AdjuHeap(lists, max, size)


def BuildHeap(lists, size):
    for i in range(0, (size / 2))[::-1]:    #[::-1]的作用相当于reverse，逆序输出，先从最后一个非终端结点开始调整
        AdjuHeap(lists, i, size)


def HeapSort(lists):
    size = len(lists)
    BuildHeap(lists, size)
    for i in range(0, size)[::-1]:              #从大根堆中每次取出一个元素并放到数列倒数第1，2，3...
        lists[0], lists[i] = lists[i], lists[0]
        AdjuHeap(lists, 0, i)
    return lists

# print(HeapSort([49, 38, 65, 97, 76, 13, 27, 49, 55, 4]))

'''
8.基数排序
确定位数
按比较个位、十位、百位、千位...对数据进行排序
'''
import math
def radix_sort(lists, radix=10):
    k = int(math.ceil(math.log(max(lists), radix)))         #获取最大位数
    bucket = [[] for i in range(radix)]
    for i in range(1, k+1):
        for j in lists:
            bucket[j/(radix**(i-1)) % radix].append(j)
        del lists[:]
        for z in bucket:
            lists += z
            del z[:]
    return lists

print(radix_sort([49, 38, 65, 97, 76, 13, 27, 49, 55, 4,34]))