垃圾小白羊leetcode刷题记录3
我的解法：
# Definition for a binary tree node.
# class TreeNode:
# def __init__(self, x):
# self.val = x
# self.left = None
# self.right = None
class Solution:
def isSameTree(self, p: TreeNode, q: TreeNode) -> bool:
if not (p or q):
return not bool(p)^bool(q)
queue = [(p, q)]
while queue:
t1, t2 = queue.pop(0)
if bool(t1) ^ bool(t2):
return False
if not (bool(t1) | bool(t2)):
continue
if t1.val != t2.val:
return False
queue.append((t1.left, t2.left))
queue.append((t1.right, t2.right))
return True
首先判别特殊情况，若两棵树一个为空一个不为空，返回False；若两棵都为空，返回True。利用元组队列遍历两颗树，比较两棵树对应节点，若对应节点不想等或一个为空一个不为空，终止循环返回False，否则继续执行，直至队列为空。
大佬解法：
# class TreeNode:
# def __init__(self, x):
# self.val = x
# self.left = None
# self.right = None
class Solution:
def isSameTree(self, p: TreeNode, q: TreeNode) -> bool:
if (not p) and (not q):
return True
if (not p) or (not q):
return False
if p.val != q.val:
return False
return self.isSameTree(p.left, q.left) and self.isSameTree(p.right, q.right)
递归算法。首先列举各种终止条件，两个节点都为空返回True，任意一个为空返回False，两个节点值不相等返回False，再递归至左右节点的相等判断。
我的解法：
# Definition for a binary tree node.
# class TreeNode:
# def __init__(self, x):
# self.val = x
# self.left = None
# self.right = None
class Solution:
def isSymmetric(self, root: TreeNode) -> bool:
if not root:
return True
queue = [(root.left, root.right)]
while queue:
t1, t2 = queue.pop(0)
if (not t1) and (not t2):
continue
if (not t1) or (not t2):
return False
if t1.val != t2.val:
return False
queue.append((t1.left, t2.right))
queue.append((t1.right, t2.left))
return True
与判断相同树类似，判断根节点是否为空后，取左右子树做类似基于队列的迭代操作。
# Definition for a binary tree node.
# class TreeNode:
# def __init__(self, x):
# self.val = x
# self.left = None
# self.right = None
class Solution:
def isSymmetric(self, root: TreeNode) -> bool:
if not root:
return True
def ivs_eql(lt, rt):
if (not lt) and (not rt):
return True
if (not lt) or (not rt):
return False
if lt.val != rt.val:
return False
return ivs_eql(lt.left, rt.right) and ivs_eql(lt.right, rt.left)
return ivs_eql(root.left, root.right)
递归算法，判断两子树是否对称相等。
我的解法：
# Definition for a binary tree node.
# class TreeNode:
# def __init__(self, x):
# self.val = x
# self.left = None
# self.right = None
class Solution:
def maxDepth(self, root: TreeNode) -> int:
if not root:
return 0
queue = [(1, root)]
while queue:
depth, node = queue.pop(0)
if node.left:
queue.append((depth+1, node.left))
if node.right:
queue.append((depth+1, node.right))
return depth
建立队列遍历树，依次压入各个节点及其对应的深度，返回遍历结束后的深度。
大佬解法：
class Solution:
def maxDepth(self, root: TreeNode) -> int:
if not root:
return 0
return max([self.maxDepth(root.left), self.maxDepth(root.right)]) + 1
递归算法，父节点最大深度等于两子节点最大深度加一。
我的解法：
class Solution:
def levelOrderBottom(self, root: TreeNode) -> List[List[int]]:
if not root:
return []
queue = [(d, root)]
vals = [[]]
while queue:
d, node = queue.pop(0)
vals[d-1].append(node.val)
if node.left:
queue.append((d+1, node.left))
if node.right:
queue.append((d+1, node.right))
if (node.left or node.right) and len(vals)<=d+1:
vals.append([])
return vals[::-1]
实际为自顶向下遍历再倒转。利用记录树深度的队列自顶向下遍历树，遍历同时将不同深度的节点值记录到嵌套列表中。每层遍历中若深度增加，则在嵌套列表中再添加一个新列表以储存下一深度节点值。
我的解法：
class Solution:
def sortedArrayToBST(self, nums: List[int]) -> TreeNode:
if len(nums) == 0:
return None
n = len(nums)
node = TreeNode(nums[n//2])
node.left = self.sortedArrayToBST(nums[:n//2])
node.right = self.sortedArrayToBST(nums[n//2+1:])
return node
递归算法，利用平衡二叉搜索树的子树也是平衡二叉搜索树，每层递归定义一个父节点。
我的解法：
class Solution:
def isBalanced(self, root: TreeNode) -> bool:
def depth(node):
if not node:
return 0
return max([depth(node.left), depth(node.right)])+1
if not root:
return True
return (abs(depth(root.left)-depth(root.right)) < 2) and (self.isBalanced(root.left)) and (self.isBalanced(root.right))
定义函数depth计算树的深度，基本思路为树深度为两子树深度最大值加1。若树为平衡二叉树，则每个树节点的左右子树深度之差小于等于1。因此需要递归判断各节点对应子树的左右子树高度差是否小于等于1，且左右子树都为平衡二叉树。深度计算时间复杂度为logn， 遍历节点时间复杂度n，总时间复杂度O(nlogn)。
大佬解法：
class Solution:
def isBalanced(self, root: TreeNode) -> bool:
def helper(node):
if not node:
return 0
left = helper(node.left)
if left == -1:
return -1
right = helper(node.right)
if right == -1:
return -1
return max([left+1, right+1]) if abs(left-right)<2 else -1
if not root:
return True
return helper(root) != -1
在计算子树高度时，同时判断该子树是不是平衡二叉树，若不是高度记为-1。若某树的子树高度为-1，整棵树的高度也为-1，那么整棵树不是平衡二叉树。
我的解法：
class Solution:
def minDepth(self, root: TreeNode) -> int:
if not root:
return 0
if root.left and not root.right:
return self.minDepth(root.left)+1
if not root.left and root.right:
return self.minDepth(root.right)+1
return min([self.minDepth(root.left)+1, self.minDepth(root.right)+1])
递归算法。对任意节点，若它的左右子节点都存在，它的最小深度为左右子节点最小深度较小值加1；若左右子节点只有一个存在，它的最小深度为存在节点最小深度加1；若无子节点，其最小深度为1。
我的解法：
class Solution:
def hasPathSum(self, root: TreeNode, sum: int) -> bool:
if not root:
return False
queue = [(root.val, root)]
while queue:
s, node = queue.pop(0)
if (s == sum) & ((not node.left) & (not node.right)):
return True
if node.left:
queue.append((s+node.left.val, node.left))
if node.right:
queue.append((s+node.right.val, node.right))
return False
遍历整棵树，每个节点记录自根节点始到当前节点的加和值，若该节点加和值等于目标值且该节点为叶节点，返回True，否则继续遍历，直至最终无满足条件节点，返回False。
class Solution:
def hasPathSum(self, root: TreeNode, sum: int) -> bool:
if not root:
return False
sum -= root.val
if (sum == 0) and (not root.left) and (not root.right):
return True
return self.hasPathSum(root.left, sum) or self.hasPathSum(root.right, sum)
递归算法，判断当前节点是否是叶节点且满足sum条件，若不满足则用sum减去当前节点值分别作为左右子节点的目标值递归调用本函数。
class Solution:
def generate(self, numRows: int) -> List[List[int]]:
tri_list = [[1]]
for i in range(1,numRows):
new_row = tri_list[i-1]+[0]
for j in range(1,len(new_row)):
new_row[j] += tri_list[i-1][j-1]
tri_list.append(new_row)
return tri_list[:numRows]
利用杨辉三角的每行为上一行的错一位相加，逐层产生杨辉三角每一层输出。
我的解法：
class Solution:
def getRow(self, rowIndex: int) -> List[int]:
l = [1]
for k in range(0, rowIndex):
l += [1]
for i in range(k,0,-1):
l[i] = l[i]+l[i-1]
return l
动态规划，每层除第一和最后一个元素外，第i个元素的更新可以满足l[i] = l[i] + l[i-1]，为了防止前一位元素的更新对后续元素更新的影响，每层元素更新时，采用从后往前更新。
我的解法：
class Solution:
def maxProfit(self, prices: List[int]) -> int:
if not prices:
return 0
min_num = prices[0]
profit, max_prf = 0, 0
for i in range(1, len(prices)):
if prices[i] < min_num:
min_num = prices[i]
else:
profit = prices[i] - min_num
max_prf = max([profit, max_prf])
return max_prf
遍历一遍数组找到最大利润，关键在于记录更新遍历过程中的当前最小值以及当前最大利润。若遍历到的元素小于当前最小值，则更新当前最小值，其余情况下计算当前遍历到的元素与当前最小值的差，更新差的最大值记录。时间复杂度O(n)。
我的解法：
class Solution:
def singleNumber(self, nums: List[int]) -> int:
d = {
}
for num in nums:
if not d.get(num):
d[num] = 1
else:
d[num] += 1
for n in d:
if d[n] == 1:
return n
遍历数组，用字典记录每个值出现的次数，再遍历一次字典，返回值为1的元素，时间复杂度O(n)，空间复杂度O(n)。
大佬解法：
class Solution:
def singleNumber(self, nums: List[int]) -> int:
return reduce(lambda x,y: x^y, nums)
运用亦或位运算，利用性质a⊕a = 0, a⊕0 = a，最终唯一元素结果即为a1⊕a2⊕…⊕an。时间复杂度O(n)，空间复杂度O(1)。
我的解法：
class Solution:
def hasCycle(self, head: ListNode) -> bool:
if not head:
return
d = {
head:1}
while 1:
if head.next is None:
return False
elif d.get(head.next):
return True
else:
d[head.next] = 1
head= head.next
遍历链表，利用字典记录出现过的节点，若遍历到的节点存在于字典中，则该链表存在环；若遍历到None，则该链表不存在环。时间复杂度O(n)，空间复杂度O(n)。
大佬解法：
class Solution:
def hasCycle(self, head: ListNode) -> bool:
if not head:
return
p, q = head, head
while 1:
if (q is None) or (q.next is None):
return False
q = q.next.next
p = p.next
if p == q:
return True
使用双指针，其中一个指针一次向前移动一格，另一个一次向前移动两格。若快指针遇到None，则该链表中没有环；若快指针与慢指针重合，则说明链表中有环，快指针追上了慢指针。时间复杂度O(n)，空间复杂度O(1)。
我的解法：
class Solution:
def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> ListNode:
na, nb, A, B = 0, 0, headA, headB
while A:
na += 1
A = A.next
while B:
nb += 1
B = B.next
if na >= nb:
for i in range(0,na-nb):
headA = headA.next
else:
for i in range(0,nb-na):
headB = headB.next
while 1:
if not (headA or headB):
return None
if headA == headB:
return headA
headA = headA.next
headB = headB.next
首先分别遍历两链表，分别得到两个链表的长度，长度较长的链表头指针向后移动，保证两个链表长度相同后开始同时遍历，一一比对各自的节点，若出现相同节点，则返回当前节点；若到链表尾仍然没有出现相同节点，返回None。时间复杂度O(n+m)，空间复杂度啊O(1)。
大佬解法：
class Solution:
def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> ListNode:
pA, pB = headA, headB
while 1:
if pA == pB:
return pA
if (not pA) and (not pB):
return
if not pA:
pA = headB
pB = pB.next
elif not pB:
pB = headA
pA = pA.next
else:
pA = pA.next
pB = pB.next
神奇解法，当pA遍历到链表尾后，指向B链表头部，当pB遍历到链表尾后，指向A链表头部。当较长链表指针指向较短链表头部后，两链表待比较长度相同，此时再遍历一遍短链表即可判断是否为相交链表。时间复杂度O(n+m)，空间复杂度啊O(1)。（其实和我的解法是一样的，还是我的解法更好懂啊！）