Letcode刷题总结知识点

1、二叉树+链式存储+递归操作

https://www.jianshu.com/p/9503238394df

现序遍历，中序遍历，后序遍历取决于根节点，根节点现访问，在左右，；中序就是现访问左边子树的叶子结点，访问根节点，访问右子树。后序遍历就是最后访问根节点

self调用参数递归问题：

python方法函数中的self关键字

上面执行"a.foo(1)"语句时有个报错，说只需要一个参数，但是给了两个参数，这第二个参数是怎么来的，为什么A.foo(1)就不会出错。这里我们可以引出python类中的方法函数，方法函数指的是通过类的实例化对象调用的函数，方法函数的第一个形参表示类的实例化对象，通常写成self。执行a.foo(1)时就相当于执行A.foo(a,1)，因为A.foo()中只有一个形参，传入的参数多于需要的参数，所以发生类型错误。
我们在A的定义中重新定义foo：

class A:
    def foo(self, n):
        print(n+1)
   
a = A()

    1
    2
    3
    4
    5

现在我们在a中调用foo就不会有问题了：
https://blog.csdn.net/m0_38063172/article/details/82220501

2、

Python基础知识：

https://www.runoob.com/python3/python3-examples.html

python 队列操作：

class Queue(object):
    def __init__(self):
        self.__list = []
    def enqueue(self,item):
        # ���
        #β�����ӣ�ͷ������
        self.__list.append(item)
        #ͷ�����ӣ�β������
        # self.__list.insert(0,item)
    def dequeue(self):
        #����
        return self.__list.pop(0)
        # return self.__list.pop()
    def is_empty(self):
        #�ж��Ƿ�Ϊ��
        return self.__list == []
    def size(self):
        #�жϴ�С 
        return len(self.__list)




class Queue2(object):
    def __init__(self,size):
        self.__list = []
        self.head = -1
        self.tail = -1
        self.size = size
        
    def enqueue(self,item):
        # ���
        #β�����ӣ�ͷ������
        if self.full():
            print("quene is full")
        else:
            self.__list.append(item)
            self.tail = self.tail + 1
        #ͷ�����ӣ�β������
        # self.__list.insert(0,item)
    def dequeue(self):
        #����
        if self.is_empty():
            print("enquenu is empty")
        else:
            self.head = self.head + 1
            return self.__list.pop(0)
        # return self.__list.pop()
    def is_empty(self):
        #�ж��Ƿ�Ϊ��
        if self.head == self.tail:
            return True
        else:
            return False
    def full(self):
        if self.tail - self.head+1 == self.size:
            return True
        else:
            return False

    def size(self):
        #�жϴ�С
        return len(self.__list)

class Queue3(object):
    def __init__(self,n):
        self.__list = [None]*(n+1)
        self.head = 0
        self.tail = 0
        self.size = 0
        
    def enqueue(self,e):
        #入队
        if self.full():
            self.resize(self.get_capaticty() * 2)  # 如果队列满，以当前队列容积的2倍进行扩容
        self.__list[self.tail] = e
        self.tail = (self.tail+1) % len(self.__list)
        self.size += 1

    def dequeue(self):
        if self.is_empty():
            raise Exception("Cannot dequeue from en empty queue")
        
        result = self.__list[self.head]
        self.__list[self.head] = None
        self.head = (self.head+1) % len(self.__list)
        self.size -= 1

        # 如果元素个数少于容积的1/4并且元素个数
        if self.size < self.get_capaticty() // 4 and self.get_capaticty() > 1:
            self.resize(self.get_capaticty() // 2)
        return result
    def is_empty(self):
        #判断队列是否为空
        return self.size == 0

    def get_capaticty(self):
        # 获取队列容积（实际可存储元素个数）
        return self.__len__() - 1

    def full(self):
        #判断队列是否为满
        return (self.tail+1)% len(self.__list) == self.head

    def __str__(self):
        return str(self.__list)

    def __len__(self):
        return len(self.__list)

    def __iter__(self):
        return iter(self.__list)

    def get_size(self):
        # 获取队列元素个数
        return self.size

    def get_capaticty(self):
        # 获取队列容积（实际可存储元素个数）
        return self.__len__() - 1

    def get_head(self):
        # 获取队首
        return self.__list[self.head]

    def resize(self, new_capacity):
        new_arr = [None] * (new_capacity+1)
        for i in range(self.size):
            new_arr[i] = self.__list[(i+self.head) % len(self.__list)]

        self.__list = new_arr
        self.head = 0
        self.tail = self.size


import datetime
if __name__ == '__main__':
    loop_queue = Queue3(10)
    # s.enqueue(1)
    # s.enqueue(2)
    # s.enqueue(3)
    # print(s.dequeue())
    # print(s.dequeue())
    # print(s.dequeue())


    start_time = datetime.datetime.now()
    for i in range(5000000):
        loop_queue.enqueue(i)
    print('---------测试----------')
    print('Loop_Queue： size = {0} , capacity = {1}
'.format(loop_queue.get_size(), loop_queue.get_capaticty()), loop_queue)
    print('is_empty：', loop_queue.is_empty())
    print('is_full：', loop_queue.full())
    

    for i in range(5000000):
        loop_queue.dequeue()
    last_time = datetime.datetime.now() - start_time
    print('
---------测试dequeue----------')
    print('Loop_Queue： size = {0} , capacity = {1}
'.format(loop_queue.get_size(), loop_queue.get_capaticty()),
        loop_queue)
    print('is_empty：', loop_queue.is_empty())
    print('is_full：', loop_queue.full())
    print('Loop_Queue epertate time', last_time)

2、

744. 寻找比目标字母大的最小字母

给定一个只包含小写字母的有序数组letters 和一个目标字母 target，寻找有序数组里面比目标字母大的最小字母。

在比较时，数组里字母的是循环有序的。举个例子：

• 如果目标字母 target = 'z' 并且有序数组为 letters = ['a', 'b']，则答案返回 'a'。
• 如果目标字母 target = 'n' 并且有序数组为 letters = ['m', 'z', 'c', 'f', 'j'] ，则答案返回 'z' 。

示例：

输入:
letters = ["c", "f", "j"]
target = "a"
输出: "c"

输入:
letters = ["c", "f", "j"]
target = "c"
输出: "f"

输入:
letters = ["c", "f", "j"]
target = "d"
输出: "f"

输入:
letters = ["c", "f", "j"]
target = "g"
输出: "j"

输入:
letters = ["c", "f", "j"]
target = "j"
输出: "c"

输入:
letters = ["c", "f", "j"]
target = "k"
输出: "c"

解法1、
244ms

class Solution:

    def nextGreatestLetter(self, letters: List[str], target: str) -> str:

        t = 0

        for k in letters:

            if target < k:

                t = 1

                return k

        if t == 0:

            return letters[0]

解题2：

136ms

class Solution:

    def nextGreatestLetter(self, letters: List[str], target: str) -> str:

        letters = sorted(set(letters))

        head = 0

        tail = len(letters)-1

        while True:

            if target < letters[head] or target >= letters[tail]:

                return letters[head]

            if target == letters[head]:

                return letters[head+1]

            if target == letters[(head+tail)//2]:

                return letters[(head+tail)//2+1]

            if target > letters[(head+tail)//2]:

                head = (head+tail)//2+1

            if target < letters[(head+tail)//2]:

                tail = (head+tail)//2

解答3：
156ms

class Solution:

    def nextGreatestLetter(self, letters, target):

        letters = sorted(list(set(letters+[target])))

        return letters[0] if letters[-1] == target else letters[letters.index(target)+1]

 

 

 

 

69. x 的平方根

实现 int sqrt(int x) 函数。

计算并返回 x 的平方根，其中 x 是非负整数。

由于返回类型是整数，结果只保留整数的部分，小数部分将被舍去。

示例 1:

输入: 4
输出: 2

示例 2:

输入: 8
输出: 2
说明: 8 的平方根是 2.82842..., 
     由于返回类型是整数，小数部分将被舍去。


二分查找

class Solution:

    def mySqrt(self, x: int) -> int:

        head = 0

        tail = x

        while True:

            num = ((head + tail)//2)**2

            num2 = ((head + tail)//2 + 1)**2

            if num <= x < num2:

                return (head + tail)//2

            if num < x <= num2:

                return (head + tail)//2 + 1

            if x > ((head + tail)//2)**2:

                head = (head + tail)//2 + 1

            if x < ((head + tail)//2)**2:

                tail = (head + tail)//2

           

167. 两数之和 II - 输入有序数组

给定一个已按照升序排列 的有序数组，找到两个数使得它们相加之和等于目标数。

函数应该返回这两个下标值index1 和 index2，其中 index1 必须小于 index2。

说明:

• 返回的下标值（index1 和 index2）不是从零开始的。
• 你可以假设每个输入只对应唯一的答案，而且你不可以重复使用相同的元素。

示例:

输入: numbers = [2, 7, 11, 15], target = 9
输出: [1,2]
解释: 2 与 7 之和等于目标数 9 。因此 index1 = 1, index2 = 2 。

通过次数80,632提交次数151,493

 

class Solution:

    def twoSum(self, numbers: List[int], target: int) -> List[int]:

        n = len(numbers)

        i = 0

        j = n - 1

        while i < j:

            sumres = numbers[i] + numbers[j]

            if sumres == target:

                return [i+1, j+1]

            elif sumres > target:

                j -= 1

            else:

                i += 1

对碰法

 

https://blog.csdn.net/qq_17550379/article/details/80512745