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