20200407 算法与数据结构

算法与数据结构

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)

查找

  • 顺序查找
  • 二分查找 (字节跳动)

数据结构

  • 线性结构
    • 数组 (列表)
    • 链表
    • 线性结构的应用
      • 队列
  • 非线性结构
      • 一般树
      • 二叉树
        • 完全二叉树
        • 满二叉树
      • 森林
posted @ 2020-04-19 22:22  fwzzz  阅读(175)  评论(0编辑  收藏  举报