排序算法python实现集锦

1. 直接插入排序——升序

#直接插入排序   升序排序
def insert_sort(a):
    length = len(a)
    for i in range(1, length):
        if a[i] < a[i - 1]:
            j= i -1
            temp = a[i]
            while j >= 0 and temp < a[j]:
                a[j + 1] = a[j]
                j -= 1
            a[j + 1] = temp
    return a

print(insert_sort([2, 5, 2, 7, 1, 6]))

是稳定的，时间复杂度 $o(n^{2})$

2. 折半插入排序——升序

#折半插入排序   升序排序
def bi_insert_sort(a):
    length = len(a)
    for i in range(1, length):
        low = 0
        high = i - 1
        temp = a[i]
        while low <= high:
            mid = (low + high) // 2
            if a[mid] <＝ temp:
                low = mid + 1
            else:
                high = mid - 1
        for j in range(i, low, -1):
            a[j] = a[j - 1]
        a[low] = temp
    return a

print(bi_insert_sort([2, 5, 2, 7, 1, 6]))

折半插入排序算法相比较于直接插入排序算法，只是减少了关键字间的比较次数，而记录的移动次数没有进行优化，所以该算法的时间复杂度仍是 $o(n^{2})$

3. 希尔排序

#希尔排序   升序排序
def shell_sort(a):
    length = len(a)
    interval = length // 2
    while interval > 0:
        for i in range(interval, length):
            j = i - interval
            if a[i] < a[j]:
                temp = a[i]
                while j > -1:
                    if a[j] > temp:
                        a[j + interval] = a[j]
                        j -= interval
                    else:
                        break
                a[j + interval] = temp

        interval = interval // 2
    return a

print(shell_sort([49, 38, 64, 97, 76, 13, 27, 49, 55, 4]))

不稳定；

一般的初次取序列的一半为增量，以后每次减半，直到增量为1；

对于关键字的值较小的记录，其前移的过程不是一步一步的，而是跳跃性的前移，并且在最后一次对整表进行插入排序时减少了比较和排序的次数。时间复杂度 $o(n^{2})$ ，近似为O(N^1.25)

4. 冒泡排序

#冒泡排序   升序排序
def swap(index1, index2, a):
    temp = a[index1]
    a[index1] = a[index2]
    a[index2] = temp
    return a


def soap_sort(a):
    length = len(a)
    for i in range(length):
        for j in range(1, length - i):
            if a[j - 1] > a[j]:
                a = swap(j, j - 1, a)
    return a

print(soap_sort([49, 38, 64, 97, 76, 13, 27, 49, 55, 4]))

若表中记录本身为正序存放，则整个排序过程只需进行 n-1（n 为表中记录的个数）次比较，且不需要移动记录；若表中记录为逆序存放（最坏的情况），则需要 n-1趟排序，进行 n(n-1)/2 次比较和数据的移动。所以该算法的时间复杂度为 $o(n^{2})$

5. 快速排序

#快速排序   升序排序
def q_sort(a, low, high):
    temp = a[low]
    start = low
    end = high
    while low < high:
        while low < high and a[high] >= temp:
            high -= 1
        a[low] = a[high]
        while low < high and a[low] <= temp:
            low += 1
        a[high] = a[low]
    a[low] = temp
    if start < low - 1:
        a = q_sort(a, start, low - 1)
    if low + 1 < end:
        a = q_sort(a, low + 1, end)
    return a


def quick_sort(a):
    length = len(a)
    a = q_sort(a, 0, length - 1)
    return a

print(quick_sort([49, 38, 64, 97, 76, 13, 27, 49, 55, 4]))

快速排序算法的平均时间复杂度为O(nlogn)，是所有时间复杂度相同的排序方法中性能最好的排序算法。

最坏情况发生在每次划分过程产生的两个区间分别包含n-1个元素和1个元素的时候，运行时间为 $o(n^{2})$

最好情况是每次划分过程产生的区间大小都为n/2，时间复杂度为O(nlogn)

6. 选择排序

#选择排序   升序排序
def swap(a, index1, index2):
    temp = a[index1]
    a[index1] = a[index2]
    a[index2] = temp
    return a


def select_sort(a):
    length = len(a)
    for i in range(length):
        temp = a[i]
        index = i
        for j in range(i, length):
            if a[j] < temp:
                index = j
                temp = a[j]
        a = swap(a, i, index)
    return a

print(select_sort([49, 38, 64, 97, 76, 13, 27, 49, 55, 4]))

运行时间为 $o(n^{2})$

排序算法python实现集锦

猜你喜欢