20200407 算法与数据结构

目录

• 算法与数据结构
  • 1. 算法
    • 时间复杂度 O
    • 空间复杂度
    • 算法
      • 冒泡排序
      • 选择排序
      • 插入排序
      • 快速排序
    • 查找
    • 数据结构

算法与数据结构

1. 算法

衡量一个算法好坏的指标

时间复杂度 O

衡量一个算法执行效率快慢的指标

• 问：有两个程序，哪个程序执行的效率更快？怎么比较？
  答：使用time模块来进行比较。
• 问：使用time模块比较的前提是啥?
  答：两个程序运行的硬件环境都要一样

因此，使用time模块来进行比较，就不太合适了。所以，我们使用程序执行的大概次数来表示时间复杂度，使用O()记

如何一眼判断时间复杂度？

• 循环减半的过程O(logn)
• 几次循环就是n的几次方的复杂度

空间复杂度

当前程序运行的时候, 是否需要向操作系统额外的申请内存空间

现阶段，由于内存非常的便宜。所以写程序的时候，也不是特别的要考虑是否节省内存。微博，内存最大 196G

算法

冒泡排序

#### 最坏时间复杂度是：O(n^2)  最优的时间复杂度是：O(n)
def bubble_sort(li):
    for i in range(len(li)-1):
        flag = True
        for j in range(len(li) - i - 1):
            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[j] < li[minLoc]:
                li[j], li[minLoc] = li[minLoc], li[j]

插入排序

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

        while j>=0 and li[j] > tmp:
            li[j+1] = li[j] ### li[2] = li[1]=7  [5,7,7,6,3,1,2,9,8]
            j = j - 1 ## j=0

        li[j+1] = tmp

快速排序

#### 时间复杂度：O(nlogn)
def partition(li, left, right):  #### O(n)
    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)  ### O(logn)
        quick_sort(li, mid+1, right)

查找

• 顺序查找
• 二分查找 （字节跳动）

数据结构

• 线性结构
  • 数组 (列表)
  • 链表
  • 线性结构的应用
    • 队列
    • 栈
• 非线性结构
  • 树
    • 一般树
    • 二叉树
      • 完全二叉树
      • 满二叉树
    • 森林