垃圾小白羊leetcode刷题记录3

我的解法：

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = Noneclass 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 Falseif not (bool(t1) | bool(t2)):continueif t1.val != t2.val:return Falsequeue.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 = Noneclass Solution:def isSameTree(self, p: TreeNode, q: TreeNode) -> bool:if (not p) and (not q):return Trueif (not p) or (not q):return False if p.val != q.val:return Falsereturn 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 = Noneclass Solution:def isSymmetric(self, root: TreeNode) -> bool:if not root:return Truequeue = [(root.left, root.right)]while queue:t1, t2 = queue.pop(0)if (not t1) and (not t2):continueif (not t1) or (not t2):return Falseif t1.val != t2.val:return Falsequeue.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 = Noneclass Solution:def isSymmetric(self, root: TreeNode) -> bool:if not root:return Truedef ivs_eql(lt, rt):if (not lt) and (not rt):return Trueif (not lt) or (not rt):return Falseif lt.val != rt.val:return Falsereturn 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 = Noneclass Solution:def maxDepth(self, root: TreeNode) -> int:if not root:return 0queue = [(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 0return 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 Nonen = 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 0return max([depth(node.left), depth(node.right)])+1if not root:return Truereturn (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 0left = helper(node.left)if left == -1: return -1right = helper(node.right)if right == -1: return -1return max([left+1, right+1]) if abs(left-right)<2 else -1if not root:return Truereturn helper(root) != -1

在计算子树高度时，同时判断该子树是不是平衡二叉树，若不是高度记为-1。若某树的子树高度为-1，整棵树的高度也为-1，那么整棵树不是平衡二叉树。

我的解法：

class Solution:def minDepth(self, root: TreeNode) -> int:if not root:return 0if root.left and not root.right:return self.minDepth(root.left)+1if not root.left and root.right:return self.minDepth(root.right)+1return 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 Falsequeue = [(root.val, root)]while queue:s, node = queue.pop(0)if (s == sum) & ((not node.left) & (not node.right)):return Trueif 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 Falsesum -= root.valif (sum == 0) and (not root.left) and (not root.right):return Truereturn 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 0min_num = prices[0]profit, max_prf = 0, 0for i in range(1, len(prices)):if prices[i] < min_num:min_num = prices[i]else:profit = prices[i] - min_nummax_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] = 1else:d[num] += 1for 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:returnd = {head:1}while 1:if head.next is None:return Falseelif d.get(head.next):return Trueelse:d[head.next] = 1head= head.next

遍历链表，利用字典记录出现过的节点，若遍历到的节点存在于字典中，则该链表存在环；若遍历到None，则该链表不存在环。时间复杂度O(n)，空间复杂度O(n)。

大佬解法：

class Solution:def hasCycle(self, head: ListNode) -> bool:if not head:returnp, q = head, headwhile 1:if (q is None) or (q.next is None):return Falseq = q.next.nextp = p.nextif 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, headBwhile A:na += 1A = A.nextwhile B:nb += 1B = B.nextif na >= nb:for i in range(0,na-nb):headA = headA.nextelse:for i in range(0,nb-na):headB = headB.nextwhile 1:if not (headA or headB):return Noneif headA == headB:return headAheadA = headA.nextheadB = headB.next

首先分别遍历两链表，分别得到两个链表的长度，长度较长的链表头指针向后移动，保证两个链表长度相同后开始同时遍历，一一比对各自的节点，若出现相同节点，则返回当前节点；若到链表尾仍然没有出现相同节点，返回None。时间复杂度O(n+m)，空间复杂度啊O(1)。

大佬解法：

class Solution:def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> ListNode:pA, pB = headA, headBwhile 1:if pA == pB:return pAif (not pA) and (not pB):returnif not pA:pA = headBpB = pB.nextelif not pB:pB = headApA = pA.nextelse:pA = pA.nextpB = pB.next

神奇解法，当pA遍历到链表尾后，指向B链表头部，当pB遍历到链表尾后，指向A链表头部。当较长链表指针指向较短链表头部后，两链表待比较长度相同，此时再遍历一遍短链表即可判断是否为相交链表。时间复杂度O(n+m)，空间复杂度啊O(1)。（其实和我的解法是一样的，还是我的解法更好懂啊！）

垃圾小白羊leetcode刷题记录3相关推荐

垃圾小白羊leetcode刷题记录1
我的解法: def twoSum(self, nums: List[int], target: int) -> List[int]:for i, num in enumerate(nums):f ...
垃圾小白羊leetcode刷题记录2
我的解法: class Solution:def countAndSay(self, n: int) -> str:if n == 1:return "1"i = 1obj ...
LeetCode刷题记录15——21. Merge Two Sorted Lists（easy）
LeetCode刷题记录15--21. Merge Two Sorted Lists(easy) 目录 LeetCode刷题记录15--21. Merge Two Sorted Lists(easy) ...
LeetCode刷题记录14——257. Binary Tree Paths（easy）
LeetCode刷题记录14--257. Binary Tree Paths(easy) 目录前言题目语言思路源码后记前言数据结构感觉理论简单,实践起来很困难. 题目给定一个二叉树, ...
LeetCode刷题记录13——705. Design HashSet（easy）
LeetCode刷题记录13--705. Design HashSet(easy) 目录 LeetCode刷题记录13--705. Design HashSet(easy) 前言题目语言思路源 ...
LeetCode刷题记录12——232. Implement Queue using Stacks（easy）
LeetCode刷题记录12--232. Implement Queue using Stacks(easy) 目录 LeetCode刷题记录12--232. Implement Queue usin ...
LeetCode刷题记录11——290. Word Pattern（easy）
LeetCode刷题记录11--290. Word Pattern(easy) 目录 LeetCode刷题记录11--290. Word Pattern(easy) 题目语言思路源码后记题目 ...
LeetCode刷题记录10——434. Number of Segments in a String（easy）
LeetCode刷题记录10--434. Number of Segments in a String(easy) 目录 LeetCode刷题记录9--434. Number of Segments ...
LeetCode刷题记录9——58. Length of Last Word（easy）
LeetCode刷题记录9--58. Length of Last Word(easy) 目录 LeetCode刷题记录9--58. Length of Last Word(easy) 题目语言思 ...

垃圾小白羊leetcode刷题记录3

垃圾小白羊leetcode刷题记录3相关推荐

最新文章

热门文章