学习笔记 Day 21 (数据结构算法 -- 排序与搜索 2)

希尔排序:插入排序的一种

实现:

def shell_sort(a_list):
    '''希尔排序'''
    n = len(a_list)
    gap = n // 2 # 步长
    while gap >= 1:
        for j in range(gap,n):
            i = j
            while i > 0:
                if a_list[i] < a_list[i-gap]:
                    a_list[i],a_list[i-gap] = a_list[i-gap],a_list[i]
                else:
                    break
            gap //= 2

时间复杂度(最坏):o(n^2)

稳定性:不稳定

快速排序:

上图:low指针找比54小的数据,放在左边.high找比54大的数据, 放右边.54最后放在两个指针的交汇处.

代码实现:

# coding:utf-8

def quick_sort(alist,frist,last):
    """快速排序"""
    # 终止条件
    if frist >= last:
        return
    # n = len(alist) # 长度
    low = frist  #
    high = last #
    mid_value = alist[frist] # 要快速排序的值
    while low < high: # 让下面两个循环能交替执行
        while low < high and alist[high] >= mid_value:
            high -= 1
        alist[low] = alist[high]
        while low < high and alist[low] < mid_value:
            low += 1
        alist[high] = alist[low]
    # 从循环退出时, low == high
    alist[low] = mid_value
    # 此时,左边 alist[:low-1]  右边 alist[low+1:] 但此时会创建新列表,我们需要在原列表操作

    # 最左边快速排序
    quick_sort(alist,frist,low-1)
    # 最右边快速排序
    quick_sort(alist,low+1,last)
if __name__ == '__main__':
    lists = [12,33,54,2,443,5,65,43,65,75,323,345,56]
    print(lists)
    quick_sort(lists,0,len(lists)-1)
    print(lists)

时间复杂度(最优,):nlogn  (2^x = n) ( 横向的是n次,每一次对半分,需要分logn次才能分n份)

时间复杂度(最坏): n^2(每次只分一个出来,长度为n,分n次,n^2)

稳定性:不稳定

归并排序:

 所有数据,拆成单个,在按大在右小在左排序,排序后合并,利用两个指针,指针指向的值比较小的数取下来排序,指针右或者左移.依次排序

实现:

def merge_sort(alist):
    n = len(alist)

    if n <= 1:
        return alist

    mid = n//2
    # 递归定义新的序列
    # 左边的序列
    left_list = merge_sort(alist[:mid])

    # 右边的序列
    right_list = merge_sort(alist[mid:])

    # 定义两个指针
    left_pin,right_pin = 0,0



    result = []
    while left_pin < len(left_list) and right_pin < len(right_list):
        if left_list[left_pin] <= right_list[right_pin]:
            result.append(left_list[left_pin])
            left_pin += 1
        else:
            result.append(right_list[right_pin])
            right_pin += 1

    result += left_list[left_pin:]
    result += right_list[right_pin:]
 # 在退出循环时,有某一指针指向完毕了,此时需要将另一个序列加入result中
    return result
if __name__ == '__main__':
    lists = [12,33,54,2,443,5,65,43,65,75,323,345,56]
    print(lists)
    # quick_sort(lists,0,len(lists)-1)
    # print(lists)
    result = merge_sort(lists)
    print(result)

时间复杂度(最优,):nlogn  (2^x = n)

时间复杂度(最坏): nlogn

稳定性:稳定

搜索:

        二分法查找:

查找的对象要是排序之后的.

递归实现:

def binary_search(alist,item):
    n = len(alist)
    if n > 0:
        mid = n//2
    
        if alist[mid] == item:
            return True
        elif alist[mid] < item:
            return binary_search(alist[:mid],item)
        else:
            return binary_search(alist[mid+1:],item)
    return False

非递归:

def binary_search(alist,item):
    n = len(alist)
    frist = 0
    last = n - 1
    mid = (frist + last)//2

    while frist <= last:
        if alist[mid] = item:
            return Ture
        elif alist[mid] < item:
            last = mid - 1
        else:
            frist = mid + 1
    return Flase

时间复杂度(最优):1

时间复杂度(最坏):logn