数据结构与算法

数据结构与算法

算法衡量的标准：

1.时间复杂度：

? 两个程序的运行时间如何衡量？

? 答：用time模块来判断，time.time()来进行计算，前提是两段程序必须运行在同一个硬件相同（cpu）的环境下，才会有意义

因此，我们使用时间差的方式来衡量一个程序是否快慢没有任何的意义。所以使用程序执行的大概次数，来衡量程序的执行快慢，这种衡量的方式称之为时间复杂度，使用O()来记

如何判断时间复杂度？

? 循环减半的过程O(logn)

? 几次循环就是n的几次方的复杂度

2.空间复杂度：

这段程序运行的过程，是否占用了内存空间

常见的排序算法

算法：

? 排序算法：

? 冒泡排序

? 选择排序

? 插入排序

? 快速排序

? 希尔排序

? 桶排序（计数排序）

? 动态规划 贪心（分糖果，人民币问题） 背包问题

? 查找：

? 顺序查找

? 二分查找

# 冒泡排序
# 时间复杂度：最差的情况：O(n^2)    最好的情况：O(n)
# 空间复杂度: O(1)

# 先找到最大的数放列表末尾位置，从右往左排
def bubble_sort(li):
    for i in range(len(li) - 1):
        for j in range(len(li) - 1 - i):
            if li[j] > li[j + 1]:
                li[j], li[j + 1] = li[j + 1], li[j]


# 改良
def bubble_sort2(li):
    for i in range(len(li) - 1):
        flag = True
        for j in range(len(li) - 1 - i):
            if li[j] > li[j + 1]:
                li[j], li[j + 1] = li[j + 1], li[j]
                flag = False
        if flag:
            return


# 选择排序
# 时间复杂度是： O（n^2）

# 先找到最小的数放在列表的起始位置，从左往右排
def select_sort(li):
    for i in range(len(li)):
        minloc = i
        for j in range(i + 1, len(li)):
            if li[minloc] > li[j]:
                li[minloc], li[j] = li[j], li[minloc]


# 插入排序
# 时间复杂度： O(n^2)
def insert_sort(li):
    for i in range(1, len(li)):
        tmp = li[i]
        j = i - 1

        while j >= 0 and li[j] > tmp:
            li[j + 1] = li[j]
            j = j - 1
        li[j - 1] = tmp


# 快速排序
# 时间复杂度：  O(nlogn）

def partition(li, left, right):
    tmp = li[left]

    while left < right:
        while left < right and li[right] >= tmp:
            right = right - 1
        li[left] = li[right]

        while left < right and li[left] <= tmp:
            left = left + 1
        li[right] = li[left]
    li[left] = tmp

    return left


def quick_sort(li, left, right):
    if left < right:
        mid = partition(li, left, right)  # 归位函数
        quick_sort(li, left, mid - 1)
        quick_sort(li, mid + 1, right)


li = [7, 5, 4, 6, 3, 8, 2, 9, 1]
# li = [1, 2, 3, 4, 5, 6]
# bubble_sort(li)
# select_sort(li)
# select_sort(li)
quick_sort(li, 0, len(li)-1)
print(li)

数据结构与算法

原文：https://www.cnblogs.com/godlover/p/12618735.html