六种排序 python

六种排序

1 选择排序

• 思想：首先记录待排序的第一个元素下标k，然后每一趟从待排序的记录中选择小于data[k]的最小元素，顺序放在已排好序子表的最后，直到全部排序完毕
• 时间复杂度：O(n^2)
• 空间复杂度：O(1)
• 稳定性：不稳定

def select_sort(data):
    n=len(data)
    for i in range(n-1):
        min=i
        for j in range(i+1,n):
            if data[min]>data[j]:
                min=j
        if min!=i:
            data[i],data[min]=data[min],data[i]
    return data

select_sort([1,3,5,2,4])

[1, 2, 3, 4, 5]

2 冒泡排序

• 思想：将数组头部看成水面，数组尾部看成水底，最小（或最大）的元素上浮（或下沉）直到 结束，采用的是比较元素大小然后交换元素值的思想，每次都选择未排序的 元素中最小或最大元素送达指定的位置。
• 时间复杂度：最好情况，数组本身是正序的，O(n)；最坏情况，数组是反序的，O(n^{2)；平均时间复杂度为O(n}2)
• 空间复杂度：O(1)
• 稳定性：稳定

def maopao(data):
    n=len(data)
    for i in range(n-1):
        for j in range(i+1,n):
            if data[i]>data[j]:
                data[i],data[j]=data[j],data[i]
    return data

maopao([13,2,5,4])

[2, 4, 5, 13]

3 插入排序

• 思想：将原序列分为有序区和无序区,初始时data[0]自成一个有序区，每次外部循环将无序区的第一个元素插入到有序区的适 当位置，同时有序区元素加1，无序区元素减1，这样直到无序区的元素为0
• 时间复杂度：最好情况，初始数组为正序（此处为递增），O(n)；最坏情况，初始数组为反 序，O(n2)；平均时间复杂度为O(n2)
• 空间复杂度：O(1)
• 稳定性：稳定。当data[i]=datda[i-1]时，相对位置不变，所以是稳定的排序

def insert(data):
    n=len(data)
    for i in range(1,n):
        for j in range(i,0,-1):
            if data[j]<data[j-1]:
                data[j]=data[j-1]
    return data

4. 希尔排序

• 思想：本质上还是属于插入排序，只不过是先对序列分组，然后组内直接插入，同时，分组数 由多到少，组内元素由少到多，顺序性由差到好，直到最后一步组间距为1时， 直接插入排序的数组已经基本有序了

• 时间复杂度：O(nlogn)约为O(1.3n)

• 空间复杂度：O(1)

• 稳定性：不稳定

def direct_insertion_sort(d):  # 直接插入排序，因为要用到后面的希尔排序，所以转成function
    d1 = [d[0]]
    for i in d[1:]:
        state = 1
        for j in range(len(d1) - 1, -1, -1):
            if i >= d1[j]:
                d1.insert(j + 1, i)  # 将元素插入数组
                state = 0
                break
        if state:
            d1.insert(0, i)
    return d1


def shell_sort(d):  # d 为乱序数组，l为初始增量,其中l<len(d),取为len(d)/2比较好操作。最后还是直接省略length输入
    length = int(len(d) / 2)  # 10
    num = int(len(d) / length)  # 2
    while 1:

        for i in range(length):
            d_mid = []
            for j in range(num):
                d_mid.append(d[i + j * length])
            d_mid = direct_insertion_sort(d_mid)
            for j in range(num):
                d[i + j * length] = d_mid[j]
        # print(d)
        length = int(length / 2)
        if length == 0:
            return d
            break
        # print('length:',length)
        num = int(len(d) / length)



d0 = [2, 15, 5, 9, 7, 6, 4, 12, 5, 4, 2, 64, 5, 6, 4, 2, 3, 54, 45, 4, 44]  # 原始乱序    d1 = shell_sort(d0)
shell_sort(d0)

[2, 2, 2, 3, 4, 4, 4, 4, 5, 5, 5, 6, 6, 7, 9, 12, 15, 44, 45, 54, 64]

5 快速排序

• 思想：分治的思想，将大问题转化为小问题，递归的思想，最重要的过程就是划分，划分结束 了，数组也就排好序了，快速排序是排序算法中非常重要的一种
  先从数列中取出一个数作为基准数（枢轴）。分区过程将比这个数大的数全放到它的右边，小于或等于它的数全放到它的左边。 (升序)再对左右区间重复第二步，直到各区间只有一个数。
• 时间复杂度：O(nlogn)
• 稳定性：不稳定

# 快速排序
def quick_sort(data):
    d=[[],[],[]]
    temp=data[-1]
    for i in data:
        if i<temp:
            d[0].append(i)
        elif i>temp:
            d[2].append(i)
        else:
            d[1].append(i)
    for d1 in d:
        if len(d1)>1:
            quick_sort(d1)
    d[0].extend(d[1])
    d[0].extend(d[2])
    return d[0]

quick_sort([1,3,546,676,8])

[1, 3, 8, 546, 676]

6 归并排序

• 思想：分治的思想，将数组分成二组 A， B，如果这二组组内的数据都是有序的，那么就可以很方便的将这二组数据进行排序。可以将 A， B 组各自再分成二组。依次类推， 当分出来的小组只有一个数据时，可以认为这个小组组内已经达到了有序，然后再合并相邻的二个小组就可以了。这样通过先递归的分解数列，再合并数列就完成了归并排序

• 时间复杂度：O(nlogn)

• 稳定性：稳定的

def merge_sort(data):
    n=len(data)
    # 2分
    mid=n//2
    d0=data[:mid]
    d1=data[mid:]
    if len(d0)>1:
        d0=merge_sort(d0)
    if len(d1)>1:
        d1=merge_sort(d1)
    for i in range(len(d1)):
        state=1
        for j in range(len(d0)):
            if d1[i]<d0[j]:
                state=0
                index=j+1
                d0.insert(j, d1[i])
                break
        if state==1:
            d0.extend(d1[1:])
            break
    return d0

d0 = [2, 15, 5, 9, 7, 6, 4, 12, 5, 4, 2, 64, 5, 6, 4, 2, 3, 54, 45, 4, 44]  
merge_sort(d0)

[2, 2, 2, 4, 4, 5, 5, 5, 6, 6, 9, 4, 5, 6, 5, 12, 2, 5, 6, 45]