001复杂度和简单排序算法

时间复杂度

时间复杂度谁小谁好
当两个时间复杂度一致的时候，拼好坏就需要拼常数项
O(1) < O(logn) < O(n) < O(nlogn) < O(n^2) < O(n^3) < O(2^n)

常数时间操作

与数据量无关，固定时间完成
数组查找某个元素：查找的时候根据偏移量来计算，可以直接得出，每次都是固定时间
±*/，位运算

非常数时间操作

与数据量有关
链表查找某个元素：查找的时候不知道存在哪个位置，需要一个一个地址的去找，所以与数据量有关，查找的快慢跟数据在哪有关，所以时间不是固定的

空间复杂度

完成此算法需要额外创建的变量，加起来就行

选择排序

从要排序的数组中，每次选出一个值，放到首位，然后第二次再从剩下的里面选出一个值放到次位，依次循环，取完即可

排序的时候每个数需要看一眼，则看N眼，n+N-1+N-2+N-3+…
每个数需要跟后面的数比较依次，则需要比较n+N-1+N-2+N-3+…
每个数需要交换一次，则需要交换N次
把这些加起来，就求出了一个公式，然后取高阶项，不要低阶项，不要高阶项的系数
n+(n-1)+(n-2)+…+1=（n+1）n/2

选择排序
每次选出一个值，放到首位
那么一共需要选出N个值，每次需要跟剩下的数进行比较大小，然后交换第一次循环的位置
def selectsort(numlst):
    if numlst is None or len(numlst) < 2:
        return -1

    num_len = len(numlst)
    for row in range(num_len):
        minindex = row
        for col in range(row + 1,num_len):
            if numlst[minindex] > numlst[col]:
                minindex = col
        numlst[minindex],numlst[row] = numlst[row],numlst[minindex]
    return numlst

冒泡排序

从第一个数开始，向后做对比，如果前一个数大于后一个数，就交换位置，依次类推
则外面需要一个循环来控制这个数
里面需要一个循环来控制这个数从当前位置开始出发，然后沉底
所以第二次循环的时候，会少比较依次

def bubblesort(numlst):

    if numlst is None or len(numlst) < 2:
        return -1

    num_len = len(numlst)
    for row in range(num_len):
        for col in range(num_len - row -1):
            if numlst[col] > numlst [col + 1]:
                numlst[col],numlst[col + 1] = numlst[col + 1],numlst[col]

    return numlst

异或运算–>位运算符

异或运算，无进位相加

交换两个数的值

a = a ^ b
b = a ^ b
a = a ^ b

数组示例题

第一问
def func(numlst):
    temp = 0
    for i in numlst:
        temp ^= i
    print(temp)

一个数与上自己取反加一，取出了自己最右侧的一

# 两种数奇，其他数偶
def func(numlst):
    # 先计算出eor
    eor = 0
    for i in numlst:
        eor ^= i  # 3^6
    print(eor)
    # 然后将数组中的数分成两部分，一部分最后一位有1，一部分最后一位没有1，取出eor最右边的1
    rightone = eor & (~eor + 1)
    onlyone = 0
    for i in numlst:
        if ((i & rightone) == 0):
            onlyone ^= i

    print(eor^onlyone,eor)

插入排序

从第二个数开始，从后往前看，只要小于前一个数，就往前移且交换位置

def insertsort(numlst):
    num_len = len(numlst)
    for row in range(num_len):
        for col in range(row - 1,0,-1):
           if numlst[col] < numlst[col - 1]:
               numlst[col],numlst[col - 1] = numlst[col - 1],numlst[col]
    return numlst

二分

时间复杂度：对数

对数器

递归

递归二分求最大值

def process(numlst,l,r):
    # 设定递归结束条件 master公式得常数项
    if l == r:
        return numlst[l]
    # 中点 master公式得常数项
    mid = l + ((r-l) >> 1) 
    leftmax = process(numlst,l,mid)
    rightmax = process(numlst,mid + 1,r)
    return max(leftmax,rightmax) #  master公式得常数项

a是递归得次数，写了多少个递归函数，就是几次
n/b是子问题得规模，也就是子问题是怎么求得，像二分就是n/2
后面那个常数项就是完成这个递归函数额外增加了哪些语句
master公式子问题规模要一致

参考资料

B站左神算法教学视频