leetcode学习之时间复杂度及刷题解析

O：最坏运行时间   Ω：最好运行时间

1.运行次数与N无关，时间复杂度即为O（1）

def algorithm(N):
    count = 0
    a = 10000
    for i in range(a):
        count += 1
    return count

2.循环运行次数与N呈线性关系，时间复杂度即为O（N）

def algorithm(N):
    count = 0
    a = 10000
    for i in range(N):
        for j in range(a):
            count += 1
    return count

3.两层循环相互独立，都与 N 呈线性关系，时间复杂度即为O（N²）

def algorithm(N):
    count = 0
    for i in range(N):
        for j in range(N):
            count += 1
    return count

对于下面的函数，时间复杂度也为O（N²）

def bubble_sort(nums):
    N = len(nums)
    for i in range(N - 1):
        for j in range(N - 1 - i):
            if nums[j] > nums[j + 1]:
                nums[j], nums[j + 1] = nums[j + 1], nums[j]
    return nums

i＝0时，里层循环n次

i=1时，里层循环n-1次

i=2时，里层循环n-2次

i＝N-2时，里层循环1次

以此类推，那么循环次数就＝n+(n-1)+(n-2)···+2+1=1/2*n²+1/2 n，复杂度也为O（N²）

4.分裂一轮后为 2 个，分裂两轮后为 4 个…… 以指数阶形式增长，时间复杂度为O（2的N次方）

def algorithm(N):
    if N <= 0: return 1
    count_1 = algorithm(N - 1)
    count_2 = algorithm(N - 1)
    return count_1 + count_2

5.“全排列”，阶乘形式增长，时间复杂度为O（N!）

def algorithm(N):
    if N <= 0: return 1
    count = 0
    for _ in range(N):
        count += algorithm(N - 1)
    return count

N=0的时候 T=1

N=1 的时候T=1

N=2的时候 T＝2*1（在range(2)里面，有0和1两个数，而0和1的T都＝1）

N=3的时候，T＝3*2*1（在range(3）里面，有0,1,2三个数，其中2的T是2*1，1和0的T是1）

6.每轮按比例排除掉一部分情况，时间复杂度为O（logN），常见的是每轮排除一半的情况，比如二分法

def algorithm(N):
    count = 0
    i = N
    while i > 1:
        i = i / 2
        count += 1
    return count

 N=8的时候，count的执行次数T（N）=3

N=16的时候，count的执行次数T(N)=4

也就是说2的T(N)次方=N

那么T（N）=logN

也就是说循环多少次，i才等于n

7.两层循环相互独立，第一层和第二层时间复杂度分别为 O(logN) 和 O(N) ，则总体时间复杂度为 O(NlogN)

def algorithm(N):
    count = 0
    i = N
    while i > 1:
        i = i / 2
        for j in range(N):
            count += 1

题目1：

用两个栈实现一个队列。队列的声明如下，请实现它的两个函数 appendTail 和 deleteHead ，分别完成在队列尾部插入整数和在队列头部删除整数的功能。(若队列中没有元素，deleteHead 操作返回 -1 )

appendtail很容易实现，用append就可以。

但是deletehead不容易，因为pop()删除的是队列尾部的元素。所以考虑用第二个栈来存倒序之后的A，即 B.append(A.pop())，执行限制是while A。（一直到A没有元素为止）

每一次appendTail，都直接A.append就可以了。

每一次deleteHead，有三种情况：

①B中含有已经倒序好了的A，那么就return B.pop()

②A里面有元素，但是B是空的，那么就B.append(A.pop())，然后return B.pop()

③A,B都是空的，那么就return -1

代码如下：

class CQueue:

    def __init__(self):
        self.A,self.B = [],[]


    def appendTail(self, value: int) -> None:
        self.A.append(value)


    def deleteHead(self) -> int:
        if self.B:
            return self.B.pop()
        elif not self.A:
            return -1
        else:
            while self.A:
                self.B.append(self.A.pop())
            return self.B.pop()

题目2：

定义栈的数据结构，请在该类型中实现一个能够得到栈的最小元素的 min 函数在该栈中，调用 min、push 及 pop 的时间复杂度都是 O(1)。

示例:

MinStack minStack = new MinStack();
minStack.push(-2);
minStack.push(0);
minStack.push(-3);
minStack.min();   --> 返回 -3.
minStack.pop();
minStack.top();      --> 返回 0.
minStack.min();   --> 返回 -2.

push,pop,top的执行时间复杂度本来就是O(1),所以本题考察的是用O（1）来实现对一个栈的寻找最小值的操作。联系上一道题，想到用另一个栈B来储存原来的栈A的最小值（以非升序的形式），这样min()的时候返回B.pop（）就可以了。

具体过程：

1、A.push（x）：

①直接执行A.append

②如果B是空的，或者x <= B列表的最后一个数，则B也执行B.append

必须是 <= 而不是 < ，因为假如A有两个相等的最小值，在A执行一次pop以后，再执行min，返回的还是这个最小值。所以B也要对应的有两个这个相等的最小值。

2、A.pop()：

①执行A.pop()

②B要保持跟A的同步，如果A把最小的值pop出去了，那么B也要pop，如果A执行的pop不是最小值，那么不用管它（它根本没在B里面）

3、A.top()

返回A最后一个值即可

4、A.min()

返回B最后一个值即可

代码如下：

class MinStack:

    def __init__(self):
        """
        initialize your data structure here.
        """
        self.A = []
        self.B = []


    def push(self, x: int) -> None:
        self.A.append(x)
        if not self.B or x <= self.B[-1]:
            self.B.append(x)


    def pop(self) -> None:
        if self.A.pop() == self.B[-1]:
            self.B.pop()


    def top(self) -> int:
        return self.A[-1]

    def min(self) -> int:
        return self.B[-1]