数据算法结构——排序与搜索

排序算法

sorting algorithm 将一串数据依照特定顺序排序的一种算法。

排序算法的稳定性

冒泡排序

冒泡排序算法稳定

def bubble_sort(alist):
    """冒泡排序"""
    n = len(alist)
    for j in range(n-1):# 0~n-1
        count = 0
        for i in range(0,n-j-1):# 0~n-2
            # 从头走到尾
            if alist[i] > alist[i+1]:
                alist[i],alist[i+1] = alist[i+1],alist[i]
                count += 1
        if 0 == count:
            break
    return alist

__name__ = "__main__"
a = [432,32,123,643,12,64,2,77]
print(bubble_sort(a))

选择排序算法

选择排序算法不稳定

def select_sort(alist):
    """选择排序"""
    n = len(alist)
    for j in range(n-1):
        min_index = j
        for i in range(j+1,n): #1~n-1
            if alist[min_index] > alist[i]:
                min_index = i
        alist[min_index],alist[j] = alist[j],alist[min_index]
    return alist

__name__ = "__main__"
a = [432,32,123,643,12,64,2,77]
print(select_sort(a))

插入排序

算法稳定

def insert_sort(alist):
    """插入排序"""
    for i in range(1,len(alist)-1):
        for j in range (0,i):
            if alist[i-j] < alist[i-j-1]:
                alist[i-j],alist[i-j-1] = alist[i-j-1],alist[i-j]
            else:
                break
    return alist

# 插入排序的另外一种算法
def insert_sort2(alist):
    for j in range(1,len(alist)):
        i = j
        while i>0:
            if alist[i] < alist[i-1]:
                alist[i],alist[i-1] = alist[i-1],alist[i]
                i -= 1
            else:
                break
    return alist


__name__ = '__main__'
alist = [2,432,523,52,34,75,1,876,]
print(insert_sort(alist))
print(insert_sort2(alist))

希尔排序

插入排序的改进

def shell_sort(alist):
    """希尔排序"""
    n = len(alist)
    gap = n//2
    while gap>0:
        for i in range(gap,n):
            while i>0:
                if alist[i] < alist[i-gap]:
                    alist[i],alist[i-gap] = alist[i-gap],alist[i]
                    i -= gap
                else:
                    break
        gap = gap//2

    return alist

__name__ = '__main__'
alist = [42,53,14,564,32,65,10,54,28,63,29,68,45,25]
print(shell_sort(alist))

归并排序

最优时间复杂度：O(nlogn)
最坏时间复杂度：O(nlogn)
算法稳定

def merge_sort(alist):
    """归并排序"""
    n = len(alist)
    if n <=1:
        return alist
    mid = n//2

    # left 采用归并排序后形成的有序的，新的列表
    left_alist = merge_sort(alist[:mid])

    #right 采用归并排序后形成的有序的，新的列表
    right_alist = merge_sort(alist[mid:])

    # 将两个有序子序列合并成新的整体
    #merge(left,right)
    left_pointer , right_pointer = 0,0
    result = []

    while left_pointer < len(left_alist) and right_pointer < len(right_alist):
        if left_alist[left_pointer] < right_alist[right_pointer]:
            result.append(left_alist[left_pointer])
            left_pointer += 1
        else:
            result.append(right_alist[right_pointer])
            right_pointer += 1

    result += left_alist[left_pointer:]
    result += right_alist[right_pointer:]
    return result

__name__='__main__'
alist = [534,34,73,243,76,348,93,56,]
print(alist)
print(merge_sort(alist))