#3.py
```python3
# jc3找出数组中重复的数字。
# 在一个长度为 n 的数组 nums 里的所有数字都在 0～n-1 的范围内。数组中某些数字是重复的，但不知道有几个数字重复了，也不知道每个数字重复了几次。请找出数组中任意一个重复的数字。
# 示例 1：
# 输入：
# [2, 3, 1, 0, 2, 5, 3]
# 输出：2 或 3
# 限制：
# 2 <= n <= 100000
class Solution:
def findRepeatNumber(self, nums: List[int]) -> int:
c=Counter(nums)
for k,v in c.items():
if v>1:
return k
```
#4.py
```python3
# 在一个 n * m 的二维数组中，每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。
# 示例:
# 现有矩阵 matrix 如下：
# [
# [1, 4, 7, 11, 15],
# [2, 5, 8, 12, 19],
# [3, 6, 9, 16, 22],
# [10, 13, 14, 17, 24],
# [18, 21, 23, 26, 30]
# ]
# 给定 target = 5，返回 true。
# 给定 target = 20，返回 false。
class Solution:
def findNumberIn2DArray(self, matrix: List[List[int]], target: int) -> bool:
if len(matrix)==0:return False
i=0
j=len(matrix[0])-1
while i<len(matrix) and j>=0:
if matrix[i][j]<target:
i+=1
elif matrix[i][j]>target:
j-=1
else:
return True
return False
```
#5.py
```python3
# 请实现一个函数，把字符串 s 中的每个空格替换成"%20"。
# 示例 1：
# 输入：s = "We are happy."
# 输出："We%20are%20happy."
class Solution:
def findNumberIn2DArray(self, matrix: List[List[int]], target: int) -> bool:
if len(matrix)==0:return False
i=0
j=len(matrix[0])-1
while i<len(matrix) and j>=0:
if matrix[i][j]<target:
i+=1
elif matrix[i][j]>target:
j-=1
else:
return True
return False
```
#6.py
```python3
# 输入一个链表的头节点，从尾到头反过来返回每个节点的值（用数组返回）。
# 示例 1：
# 输入：head = [1,3,2]
# 输出：[2,3,1]
# Definition for singly-linked list.
# class ListNode:
# def __init__(self, x):
# self.val = x
# self.next = None
class Solution:
def reversePrint(self, head: ListNode) -> List[int]:
# res=[]
# while head:
# res.append(head.val)
# return res[::-1]
#辅助栈
res=[]
stack=[]
while head:
stack.insert(0,head)
while stack:
res.append(stack.pop(0).val)
return res
```
#7.py
```python3
# 输入某二叉树的前序遍历和中序遍历的结果，请重建该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。
# 例如，给出
# 前序遍历 preorder = [3,9,20,15,7]
# 中序遍历 inorder = [9,3,15,20,7]
# 返回如下的二叉树：
# 3
# / \
# 9 20
# / \
# 15 7
class Solution:
def buildTree(self, preorder: List[int], inorder: List[int]) -> TreeNode:
if len(preorder)==0:return None
rootval=preorder[0]
index=inorder.index(rootval)
left=inorder[:index]
right=inorder[index+1:]
t=TreeNode(-1)
t.val=rootval
t.left=self.buildTree(preorder[1:index+1],left)
t.right=self.buildTree(preorder[index+1:],right)
return t
```
#9.py
```python3
# 用两个栈实现一个队列。队列的声明如下，请实现它的两个函数 appendTail 和 deleteHead ，分别完成在队列尾部插入整数和在队列头部删除整数的功能。(若队列中没有元素，deleteHead 操作返回 -1 )
# 示例 1：
# 输入：
# ["CQueue","appendTail","deleteHead","deleteHead"]
# [[],[3],[],[]]
# 输出：[null,null,3,-1]
# 示例 2：
# 输入：
# ["CQueue","deleteHead","appendTail","appendTail","deleteHead","deleteHead"]
# [[],[],[5],[2],[],[]]
# 输出：[null,-1,null,null,5,2]
class CQueue:
def __init__(self):
self.a=[]
#b是辅助栈
self.b=[]
def appendTail(self, value: int) -> None:
while self.a:
self.b.insert(0,self.a.pop(0))
self.a.insert(0,value)
while len(self.b):
self.a.insert(0,self.b.pop(0))
#print(self.a)
def deleteHead(self) -> int:
#print(self.a)
if not self.a:return -1
return self.a.pop(0)
```
#10_1.py
```python3
# 写一个函数，输入 n ，求斐波那契（Fibonacci）数列的第 n 项。斐波那契数列的定义如下：
# F(0) = 0, F(1) = 1
# F(N) = F(N - 1) + F(N - 2), 其中 N > 1.
# 斐波那契数列由 0 和 1 开始，之后的斐波那契数就是由之前的两数相加而得出。
# 答案需要取模 1e9+7（1000000007），如计算初始结果为：1000000008，请返回 1。
#
# 示例 1：
# 输入：n = 2
# 输出：1
# 示例 2：
# 输入：n = 5
# 输出：5
class Solution:
def fib(self, n: int) -> int:
if n==0:return 0
if n==1:return 1
dp=[0]*(n+1)
dp[0]=0
dp[1]=1
for i in range(2,n+1):
dp[i]=dp[i-1]+dp[i-2]
print(dp)
return dp[-1]%(1000000007)
```
#10_2.py
```python3
# 一只青蛙一次可以跳上1级台阶，也可以跳上2级台阶。求该青蛙跳上一个 n 级的台阶总共有多少种跳法。
# 答案需要取模 1e9+7（1000000007），如计算初始结果为：1000000008，请返回 1。
# 示例 1：
# 输入：n = 2
# 输出：2
# 示例 2：
# 输入：n = 7
# 输出：21
# 示例 3：
# 输入：n = 0
# 输出：1
class Solution:
def numWays(self, n: int) -> int:
if n==0:return 1
if n==1:return 1
if n==2:return 2
dp=[0]*(n)
dp[0]=1
dp[1]=2
for i in range(2,n):
dp[i]=dp[i-1]+dp[i-2]
print(dp)
return dp[-1]%(1000000007)
```
```python3
# 把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。输入一个递增排序的数组的一个旋转，输出旋转数组的最小元素。例如，数组 [3,4,5,1,2] 为 [1,2,3,4,5] 的一个旋转，该数组的最小值为1。
# 示例 1：
# 输入：[3,4,5,1,2]
# 输出：1
# 示例 2：
# 输入：[2,2,2,0,1]
# 输出：0
class Solution:
def minArray(self, numbers: List[int]) -> int:
left=0
right=len(numbers)-1
while left<right:
mid=(left+right)//2
if numbers[mid]>numbers[right]:
left=mid+1
elif numbers[mid]<numbers[right]:
right=mid
else:right-=1
return numbers[left]
```
```python3
# 请设计一个函数，用来判断在一个矩阵中是否存在一条包含某字符串所有字符的路径。路径可以从矩阵中的任意一格开始，每一步可以在矩阵中向左、右、上、下移动一格。如果一条路径经过了矩阵的某一格，那么该路径不能再次进入该格子。例如，在下面的3×4的矩阵中包含一条字符串“bfce”的路径（路径中的字母用加粗标出）。
# [["a","b","c","e"],
# ["s","f","c","s"],
# ["a","d","e","e"]]
# 但矩阵中不包含字符串“abfb”的路径，因为字符串的第一个字符b占据了矩阵中的第一行第二个格子之后，路径不能再次进入这个格子。
#
# 示例 1：
# 输入：board = [["A","B","C","E"],["S","F","C","S"],["A","D","E","E"]], word = "ABCCED"
# 输出：true
# 示例 2：
# 输入：board = [["a","b"],["c","d"]], word = "abcd"
# 输出：false
class Solution:
def exist(self, board: List[List[str]], word: str) -> bool:
dx=[0,-1,0,1]
dy=[-1,0,1,0]
def dfs(x,y,k):
if word[k]!=board[x][y]:
return False
if k==len(word)-1:return True
t=board[x][y]
board[x][y]="*"
for i in range(4):
if 0<=x+dx[i]<=len(board)-1 and 0<=y+dy[i]<=len(board[0])-1:
if dfs(x+dx[i],y+dy[i],k+1):
return True
board[x][y]=t
for i in range(len(board)):
for j in range(len(board[0])):
print(i,j)
if dfs(i,j,0):
return True
return False
```
```python3
# 地上有一个m行n列的方格，从坐标 [0,0] 到坐标 [m-1,n-1] 。一个机器人从坐标 [0, 0] 的格子开始移动，它每次可以向左、右、上、下移动一格（不能移动到方格外），也不能进入行坐标和列坐标的数位之和大于k的格子。例如，当k为18时，机器人能够进入方格 [35, 37] ，因为3+5+3+7=18。但它不能进入方格 [35, 38]，因为3+5+3+8=19。请问该机器人能够到达多少个格子？
# 示例 1：
# 输入：m = 2, n = 3, k = 1
# 输出：3
# 示例 2：
# 输入：m = 3, n = 1, k = 0
# 输出：1
class Solution:
def movingCount(self, m: int, n: int, k: int) -> int:
def dfs(i, j, si, sj):
if i>=m or j>=n or si+sj>k or (i,j) in visited:return 0
visited.add((i,j))
return 1+dfs(i+1,j,si+1 if (i+1)%10!=0 else si-8,sj)+dfs(i,j+1,si,sj+1 if (j+1)%10!=0 else sj-8)
visited=set()
return dfs(0,0,0,0)
```
#14_1.py
```python3
# 给你一根长度为 n 的绳子，请把绳子剪成整数长度的 m 段（m、n都是整数，n>1并且m>1），每段绳子的长度记为 k[0],k[1]...k[m-1] 。请问 k[0]*k[1]*...*k[m-1] 可能的最大乘积是多少？例如，当绳子的长度是8时，我们把它剪成长度分别为2、3、3的三段，此时得到的最大乘积是18。
# 示例 1：
# 输入: 2
# 输出: 1
# 解释: 2 = 1 + 1, 1 × 1 = 1
# 示例 2:
# 输入: 10
# 输出: 36
# 解释: 10 = 3 + 3 + 4, 3 × 3 × 4 = 36
class Solution:
def cuttingRope(self, n: int) -> int:
if n<=3:
return n-1
div=n//3
remain=n%3
if remain==0:
return 3**div
if remain==1:
return 3**(div-1)*4
if remain==2:
return 2*3**div
```
#14_2.py
```python3
# 给你一根长度为 n 的绳子，请把绳子剪成整数长度的 m 段（m、n都是整数，n>1并且m>1），每段绳子的长度记为 k[0],k[1]...k[m - 1] 。请问 k[0]*k[1]*...*k[m - 1] 可能的最大乘积是多少？例如，当绳子的长度是8时，我们把它剪成长度分别为2、3、3的三段，此时得到的最大乘积是18。
# 答案需要取模 1e9+7（1000000007），如计算初始结果为：1000000008，请返回 1。
class Solution:
def cuttingRope(self, n: int) -> int:
if n<=3:
return n-1
div=n//3
remain=n%3
if remain==0:
return 3**div%1000000007
if remain==1:
return 3**(div-1)*4%1000000007
if remain==2:
return 2*3**div%1000000007
```
```python3
# 请实现一个函数，输入一个整数，输出该数二进制表示中 1 的个数。例如，把 9 表示成二进制是 1001，有 2 位是 1。因此，如果输入 9，则该函数输出 2。
# 示例 1：
# 输入：00000000000000000000000000001011
# 输出：3
# 解释：输入的二进制串 00000000000000000000000000001011 中，共有三位为 '1'。
# 示例 2：
# 输入：00000000000000000000000010000000
# 输出：1
# 解释：输入的二进制串 00000000000000000000000010000000 中，共有一位为 '1'。
# 示例 3：
# 输入：11111111111111111111111111111101
# 输出：31
# 解释：输入的二进制串 11111111111111111111111111111101 中，共有 31 位为 '1'。
class Solution:
def hammingWeight(self, n: int) -> int:
mask=1
count=0
for i in range(32):
if n&mask>0:
count+=1
mask=mask<<1
return count
```
```python3
# 实现函数double Power(double base, int exponent)，求base的exponent次方。不得使用库函数，同时不需要考虑大数问题。
# 示例 1:
# 输入: 2.00000, 10
# 输出: 1024.00000
# 示例 2:
# 输入: 2.10000, 3
# 输出: 9.26100
# 示例 3:
# 输入: 2.00000, -2
# 输出: 0.25000
# 解释: 2-2 = 1/22 = 1/4 = 0.25
class Solution:
def myPow(self, x: float, n: int) -> float:
if n==0:return 1
elif n<0: return 1.0/self.myPow(x,-n)
elif n%2==0:return self.myPow(x*x,n//2)
else:return self.myPow(x*x,n//2)*x
```
```python3
# 输入数字 n，按顺序打印出从 1 到最大的 n 位十进制数。比如输入 3，则打印出 1、2、3 一直到最大的 3 位数 999。
# 示例 1:
# 输入: n = 1
# 输出: [1,2,3,4,5,6,7,8,9]
class Solution:
def printNumbers(self, n: int) -> List[int]:
largest=9
for i in range(1,n):
largest=largest*10+9
return [i for i in range(1,largest+1)]
```
```python3
# 给定单向链表的头指针和一个要删除的节点的值，定义一个函数删除该节点。
# 返回删除后的链表的头节点。
# 注意：此题对比原题有改动
# 示例 1:
# 输入: head = [4,5,1,9], val = 5
# 输出: [4,1,9]
# 解释: 给定你链表中值为 5 的第二个节点，那么在调用了你的函数之后，该链表应变为 4 -> 1 -> 9.
# 示例 2:
# 输入: head = [4,5,1,9], val = 1
# 输出: [4,5,9]
# 解释: 给定你链表中值为 1 的第三个节点，那么在调用了你的函数之后，该链表应变为 4 -> 5 -> 9.
class Solution:
def deleteNode(self, head: ListNode, val: int) -> ListNode:
dummy=ListNode(-1)
dummy.next=head
if head.val==val:return head.next
while head and head.next:
if head.next.val==val:
return dummy.next
```
```python3
#请实现一个函数用来匹配包含'. '和'*'的正则表达式。模式中的字符'.'表示任意一个字符，而'*'表示它前面的字符可以出现任意次（含0次）。在本题中，匹配是指字符串的所有字符匹配整个模式。例如，字符串"aaa"与模式"a.a"和"ab*ac*a"匹配，但与"aa.a"和"ab*a"均不匹配。
class Solution:
def isMatch(self, s: str, p: str) -> bool:
slen=len(s)
plen=len(p)
dp=[[False]*(plen+1) for _ in range(slen+1)]
dp[0][0]=True
for i in range(plen):
if p[i]=="*":
dp[0][i+1]=dp[0][i-1]
for i in range(slen):
for j in range(plen):
if p[j]=="." or s[i]==p[j]:
dp[i+1][j+1]=dp[i][j]
elif p[j]=="*":
if s[i]!=p[j-1]:
dp[i+1][j+1]=dp[i+1][j-1]
if p[j-1]=="." or s[i]==p[j-1]:
dp[i+1][j+1]=(dp[i][j+1] | dp[i+1][j] | dp[i+1][j-1])
print(dp)
return dp[-1][-1]
```
```python3
#请实现一个函数用来判断字符串是否表示数值（包括整数和小数）。例如，字符串"+100"、"5e2"、"-123"、"3.1416"、"-1E-16"、"0123"都表示数值，但"12e"、"1a3.14"、"1.2.3"、"+-5"及"12e+5.4"都不是。
class Solution:
def isNumber(self, s: str) -> bool:
state = [
{},
# 状态1,初始状态(扫描通过的空格)
{"blank": 1, "sign": 2, "digit": 3, ".": 4},
# 状态2,发现符号位(后面跟数字或者小数点)
{"digit": 3, ".": 4},
# 状态3,数字(一直循环到非数字)
{"digit": 3, ".": 5, "e": 6, "blank": 9},
# 状态4,小数点(后面只有紧接数字)
{"digit": 5},
# 状态5,小数点之后(后面只能为数字,e,或者以空格结束)
{"digit": 5, "e": 6, "blank": 9},
# 状态6,发现e(后面只能符号位, 和数字)
{"sign": 7, "digit": 8},
# 状态7,e之后(只能为数字)
{"digit": 8},
# 状态8,e之后的数字后面(只能为数字或者以空格结束)
{"digit": 8, "blank": 9},
# 状态9, 终止状态 (如果发现非空,就失败)
{"blank": 9}
]
cur_state = 1
for c in s:
if c.isdigit():
c = "digit"
elif c in " ":
c = "blank"
elif c in "+-":
c = "sign"
if c not in state[cur_state]:
return False
cur_state=state[cur_state][c]
if cur_state not in [3,5,8,9]:
return False
return True
```
```python3
#输入一个整数数组，实现一个函数来调整该数组中数字的顺序，使得所有奇数位于数组的前半部分，所有偶数位于数组的后半部分。
class Solution:
def exchange(self, nums: List[int]) -> List[int]:
j=len(nums)-1
i=0
while i<j:
if nums[i]%2==0:
if nums[j]%2==0:
j=j-1
continue
else:
nums[i],nums[j]=nums[j],nums[i]
i=i+1
return nums
```
```python3
# 输入一个链表，输出该链表中倒数第k个节点。为了符合大多数人的习惯，本题从1开始计数，即链表的尾节点是倒数第1个节点。例如，一个链表有6个节点，从头节点开始，它们的值依次是1、2、3、4、5、6。这个链表的倒数第3个节点是值为4的节点。
class Solution:
def getKthFromEnd(self, head: ListNode, k: int) -> ListNode:
fast=head
slow=head
for i in range(k):
while fast:
return slow
```
```python3
# 定义一个函数，输入一个链表的头节点，反转该链表并输出反转后链表的头节点。
# 示例:
# 输入: 1->2->3->4->5->NULL
# 输出: 5->4->3->2->1->NULL
# 限制：
# 0 <= 节点个数 <= 5000
class Solution:
def reverseList(self, head: ListNode) -> ListNode:
if not head:return []
p=head
while q:
q.next=p
p=q
q=tmp
head.next=None
return p
```
```python3
# 输入两个递增排序的链表，合并这两个链表并使新链表中的节点仍然是递增排序的。
# 示例1：
# 输入：1->2->4, 1->3->4
# 输出：1->1->2->3->4->4
class Solution:
def mergeTwoLists(self, l1: ListNode, l2: ListNode) -> ListNode:
l=ListNode(-1)
head=l
while l1 and l2:
if l1.val<=l2.val:
l.next=l1
else:
l.next=l2
while l1:
l.next=l1
while l2:
l.next=l2
return head.next
```
```python3
# 输入两棵二叉树A和B，判断B是不是A的子结构。(约定空树不是任意一个树的子结构)
# B是A的子结构， 即 A中有出现和B相同的结构和节点值。
# 例如:
# 给定的树 A:
# 3
# / \
# 4 5
# / \
# 1 2
# 给定的树 B：
# 4
# /
# 1
# 返回 true，因为 B 与 A 的一个子树拥有相同的结构和节点值。
# 示例 1：
# 输入：A = [1,2,3], B = [3,1]
# 输出：false
# 示例 2：
# 输入：A = [3,4,5,1,2], B = [4,1]
# 输出：true
class Solution:
def isSubStructure(self, A: TreeNode, B: TreeNode) -> bool:
def dfs(a,b):
if not b:return True
if not a or a.val!=b.val:return False
return dfs(a.left,b.left) and dfs(a.right,b.right)
if not A or not B:return False
return dfs(A,B) or self.isSubStructure(A.left,B) or self.isSubStructure(A.right,B)
```
```python3
# 请完成一个函数，输入一个二叉树，该函数输出它的镜像。
# 例如输入：
# 4
# / \
# 2 7
# / \ / \
# 1 3 6 9
# 镜像输出：
# 4
# / \
# 7 2
# / \ / \
# 9 6 3 1
class Solution:
def mirrorTree(self, root: TreeNode) -> TreeNode:
def dfs(root):
if root is None:return []
root.left,root.right=root.right,root.left
if root.left:
dfs(root.left)
if root.right:
dfs(root.right)
return root
return dfs(root)
```
```python3
# 请实现一个函数，用来判断一棵二叉树是不是对称的。如果一棵二叉树和它的镜像一样，那么它是对称的。
# 例如，二叉树 [1,2,2,3,4,4,3] 是对称的。
# 1
# / \
# 2 2
# / \ / \
# 3 4 4 3
# 但是下面这个 [1,2,2,null,3,null,3] 则不是镜像对称的:
# 1
# / \
# 2 2
# \ \
# 3 3
class Solution:
def isSymmetric(self, root: TreeNode) -> bool:
def dfs(L,R):
if not L and not R:return True
if not L or not R or L.val!=R.val:return False
return dfs(L.right,R.left) and dfs(L.left,R.right)
if not root:return True
else:
return dfs(root.left,root.right)
```
```python3
# 输入一个矩阵，按照从外向里以顺时针的顺序依次打印出每一个数字。
#
# 示例 1：
# 输入：matrix = [[1,2,3],[4,5,6],[7,8,9]]
# 输出：[1,2,3,6,9,8,7,4,5]
# 示例 2：
# 输入：matrix = [[1,2,3,4],[5,6,7,8],[9,10,11,12]]
# 输出：[1,2,3,4,8,12,11,10,9,5,6,7]
class Solution:
def spiralOrder(self, matrix: List[List[int]]) -> List[int]:
res = []
while matrix:
res.extend(matrix.pop(0))
matrix=list(zip(*matrix))[::-1]
return res
```
```python3
# 定义栈的数据结构，请在该类型中实现一个能够得到栈的最小元素的 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.
class MinStack:
def __init__(self):
"""
initialize your data structure here.
"""
self.stack=[]
self.minstack=[]
def push(self, x: int) -> None:
self.stack.append(x)
if not self.minstack or x<=self.minstack[-1]:
self.minstack.append(x)
def pop(self) -> None:
x=self.stack.pop()
if x==self.minstack[-1]:
self.minstack.pop()
def top(self) -> int:
return self.stack[-1]
def min(self) -> int:
return self.minstack[-1]
```
```python3
# 输入两个整数序列，第一个序列表示栈的压入顺序，请判断第二个序列是否为该栈的弹出顺序。假设压入栈的所有数字均不相等。例如，序列 {1,2,3,4,5} 是某栈的压栈序列，序列 {4,5,3,2,1} 是该压栈序列对应的一个弹出序列，但 {4,3,5,1,2} 就不可能是该压栈序列的弹出序列。
# 示例 1：
# 输入：pushed = [1,2,3,4,5], popped = [4,5,3,2,1]
# 输出：true
# 解释：我们可以按以下顺序执行：
# push(1), push(2), push(3), push(4), pop() -> 4,
# push(5), pop() -> 5, pop() -> 3, pop() -> 2, pop() -> 1
# 示例 2：
# 输入：pushed = [1,2,3,4,5], popped = [4,3,5,1,2]
# 输出：false
# 解释：1 不能在 2 之前弹出。
class Solution:
def validateStackSequences(self, pushed: List[int], popped: List[int]) -> bool:
stack=[]
p=0
for item in pushed:
stack.insert(0,item)
while stack and popped[p]==stack[0]:
p+=1
stack.pop(0)
return not stack
```
```python3
# 从上到下打印出二叉树的每个节点，同一层的节点按照从左到右的顺序打印。
# 例如:
# 给定二叉树: [3,9,20,null,null,15,7],
# 3
# / \
# 9 20
# / \
# 15 7
# 返回：
# [3,9,20,15,7]
class Solution:
def levelOrder(self, root: TreeNode) -> List[int]:
q=[]
if root:
q.append(root)
res=[]
while q:
node=q.pop(0)
res.append(node.val)
if node.left:
q.append(node.left)
if node.right:
q.append(node.right)
return res
```
#32_2.py
```python3
# 从上到下按层打印二叉树，同一层的节点按从左到右的顺序打印，每一层打印到一行。
# 例如:
# 给定二叉树: [3,9,20,null,null,15,7],
# 3
# / \
# 9 20
# / \
# 15 7
# 返回其层次遍历结果：
# [
# [3],
# [9,20],
# [15,7]
# ]
class Solution:
def levelOrder(self, root: TreeNode) -> List[int]:
q=[]
if root:
q.append(root)
res=[]
while q:
node=q.pop(0)
res.append(node.val)
if node.left:
q.append(node.left)
if node.right:
q.append(node.right)
return res
```
#32_3.py
```python3
# 请实现一个函数按照之字形顺序打印二叉树，即第一行按照从左到右的顺序打印，第二层按照从右到左的顺序打印，第三行再按照从左到右的顺序打印，其他行以此类推。
# 例如:
# 给定二叉树: [3,9,20,null,null,15,7],
# 3
# / \
# 9 20
# / \
# 15 7
# 返回其层次遍历结果：
# [
# [3],
# [20,9],
# [15,7]
# ]
class Solution:
def levelOrder(self, root: TreeNode) -> List[List[int]]:
q=[]
if root:
q.append([root])
res=[]
while q:
nodelist=q.pop(0)
level=[]
t=[]
for node in nodelist:
t.append(node.val)
if node.left:
level.append(node.left)
if node.right:
level.append(node.right)
if level:
q.append(level)
res.append(t)
for i in range(len(res)):
if i%2==1:
res[i]=res[i][::-1]
return res
```
```python3
# 输入一个整数数组，判断该数组是不是某二叉搜索树的后序遍历结果。如果是则返回 true，否则返回 false。假设输入的数组的任意两个数字都互不相同。
# 参考以下这颗二叉搜索树：
# 5
# / \
# 2 6
# / \
# 1 3
# 示例 1：
# 输入: [1,6,3,2,5]
# 输出: false
# 示例 2：
# 输入: [1,3,2,6,5]
# 输出: true
class Solution:
def verifyPostorder(self, postorder: List[int]) -> bool:
if not postorder or len(postorder) == 0:return True
rootval=postorder[-1]
n=len(postorder)
mid=0
for i in range(n):
if postorder[i]>rootval:
break
mid=i
for i in range(mid,n-1):
if postorder[i]<rootval:
return False
left=True
if mid>0:
left=self.verifyPostorder(postorder[0:mid])
right=True
if i<n-1:
right=self.verifyPostorder(postorder[mid:-1])
return left and right
```
```python3
# 输入一棵二叉树和一个整数，打印出二叉树中节点值的和为输入整数的所有路径。从树的根节点开始往下一直到叶节点所经过的节点形成一条路径。
# 示例:
# 给定如下二叉树，以及目标和 sum = 22，
# 5
# / \
# 4 8
# / / \
# 11 13 4
# / \ / \
# 7 2 5 1
# 返回:
# [
# [5,4,11,2],
# [5,8,4,5]
# ]
class Solution:
def pathSum(self, root: TreeNode, sum: int) -> List[List[int]]:
if not root:return []
res=[]
def dfs(root,total,t):
if not root.left and not root.right:
print(t,sum,total)
if total==sum:
res.append(t)
#t=t+[root.val]
if root.left:
dfs(root.left,total+root.left.val,t+[root.left.val])
if root.right:
dfs(root.right,total+root.right.val,t+[root.right.val])
dfs(root,root.val,[root.val])
return res
```
```python3
#请实现 copyRandomList 函数，复制一个复杂链表。在复杂链表中，每个节点除了有一个 next 指针指向下一个节点，还有一个 random 指针指向链表中的任意节点或者 null。
class Node:
def __init__(self, x: int, next: 'Node' = None, random: 'Node' = None):
self.val = int(x)
self.next = next
self.random = random
class Solution:
def copyRandomList(self, head: 'Node') -> 'Node':
def dfs(root):
if not root:return
if root in visited:
return visited[root]
copy=Node(root.val,None,None)
visited[root]=copy
copy.next=dfs(root.next)
copy.random=dfs(root.random)
return copy
visited={}
return dfs(head)
```
```python3
#输入一棵二叉搜索树，将该二叉搜索树转换成一个排序的循环双向链表。要求不能创建任何新的节点，只能调整树中节点指针的指向。
class Solution:
def treeToDoublyList(self, root: 'Node') -> 'Node':
def dfs(cur):
if not cur:return
dfs(cur.left)
if self.pre:
self.pre.right=cur
cur.left=self.pre
else:
self.head=cur
self.pre=cur
dfs(cur.right)
if not root:return
self.pre=None
dfs(root)
self.head.left=self.pre
self.pre.right=self.head
return self.head
```
```python3
#请实现两个函数，分别用来序列化和反序列化二叉树。
class Codec:
def serialize(self, root):
res=[]
def dfs(root):
if not root:
res.append("#")
return
res.append(str(root.val))
#if root.left:
dfs(root.left)
#if root.right:
dfs(root.right)
dfs(root)
return ",".join(res)
def deserialize(self, data):
"""Decodes your encoded data to tree.
:type data: str
:rtype: TreeNode
"""
d=iter(data.split(","))
def dfs():
s=next(d)
if s=="#":return
node=TreeNode(int(s))
node.left=dfs()
node.right=dfs()
return node
return dfs()
```
```python3
# 输入一个字符串，打印出该字符串中字符的所有排列。
# 你可以以任意顺序返回这个字符串数组，但里面不能有重复元素。
class Solution:
def permutation(self, s: str) -> List[str]:
s="".join(sorted(s))
res=[]
def dfs(s,tmp):
if len(s)==0:
res.append(tmp)
for i in range(len(s)):
if i-1>=0 and s[i]==s[i-1]:
continue
else:
dfs(s[0:i]+s[i+1:],tmp+s[i])
dfs(s,"")
return res
```
```python3
# 数组中有一个数字出现的次数超过数组长度的一半，请找出这个数字。
# 你可以假设数组是非空的，并且给定的数组总是存在多数元素。
# 示例 1:
# 输入: [1, 2, 3, 2, 2, 2, 5, 4, 2]
# 输出: 2
class Solution:
def majorityElement(self, nums: List[int]) -> int:
nums.sort()
return nums[len(nums)//2]
```
230
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
