530. Minimum Absolute Difference in BST
找出二叉树中每两个节点的值之差的最小值
Example:
Input: 1 \ 3 / 2 Output: 1 Explanation: The minimum absolute difference is 1, which is the difference between 2 and 1 (or between 2 and 3).我的代码:没想到什么好办法,枚举出所有值进行排序对比
# Definition for a binary tree node.
# class TreeNode(object):
# def __init__(self, x):
# self.val = x
# self.left = None
# self.right = None
class Solution(object):
def getMinimumDifference(self, root):
"""
:type root: TreeNode
:rtype: int
"""
list_ = []
stack = [root]
while stack:
node = stack.pop()
if node:
list_.append(node.val)
if node.left:stack.append(node.left)
if node.right:stack.append(node.right)
list_.sort()
ans = list(map(lambda x,y:abs(x-y),list_[1:]+[list_[0]],list_))
return min(ans)
大神的代码:对二叉搜索树进行完整的排序
def getMinimumDifference(self, root):
def dfs(node, l=[]):
if node.left: dfs(node.left, l)
l.append(node.val)
if node.right: dfs(node.right, l)
return l
l = dfs(root) #如果不是BST,则需要排序
return min([abs(a-b) for a,b in zip(l, l[1:])])
这个一行排序更厉害
class Solution(object):
def getMinimumDifference(self, root):
nums = self.inorder(root)
return min(nums[i+1]-nums[i] for i in range(len(nums)-1))
def inorder(self, root):
return self.inorder(root.left) + [root.val] + self.inorder(root.right) if root else []
100 . Same Tree
判断两个树是否一样
530. Minimum Absolute Difference in BST
Example 1:
Input: 1 1 / \ / \ 2 3 2 3 [1,2,3], [1,2,3] Output: true
Example 2:
Input: 1 1 / \ 2 2 [1,2], [1,null,2] Output: false
Example 3:
Input: 1 1 / \ / \ 2 1 1 2 [1,2,1], [1,1,2] Output: false我的代码:
# Definition for a binary tree node.
# class TreeNode(object):
# def __init__(self, x):
# self.val = x
# self.left = None
# self.right = None
class Solution(object):
def isSameTree(self, p, q):
"""
:type p: TreeNode
:type q: TreeNode
:rtype: bool
"""
if not p and not q:
return True
elif not(p and q):
return False
if p.val != q.val:
return False
else:
if (p.left and q.left) and (p.right and q.right):
return self.isSameTree(p.left,q.left) and self.isSameTree(p.right,q.right)
elif (p.left and q.left) and (not p.right and not q.right):
return self.isSameTree(p.left,q.left)
elif (p.right and q.right) and (not p.left and not q.left):
return self.isSameTree(p.right,q.right)
elif (not p.left and not q.left) and (not p.right and not q.right):
return True
else:
return False
大神的代码:只能说膜拜..
The “proper” way:
def isSameTree(self, p, q):
if p and q:
return p.val == q.val and self.isSameTree(p.left, q.left) and self.isSameTree(p.right, q.right)
return p is q
The “tupleify” way:
def isSameTree(self, p, q):
def t(n):
return n and (n.val, t(n.left), t(n.right))
return t(p) == t(q)
The first way as one-liner:
def isSameTree(self, p, q):
return p and q and p.val == q.val and all(map(self.isSameTree, (p.left, p.right), (q.left, q.right))) or p is q
563. Binary Tree Tilt
计算所有节点的Tilt之和,Tilt指这个节点的所有左边子子节值和所有右边子子节值之差
Example:
Input: 1 / \ 2 3 Output: 1 Explanation: Tilt of node 2 : 0 Tilt of node 3 : 0 Tilt of node 1 : |2-3| = 1 Tilt of binary tree : 0 + 0 + 1 = 1我的代码:关于这种树的我写得都好长,喜欢用BFS
# Definition for a binary tree node.
# class TreeNode(object):
# def __init__(self, x):
# self.val = x
# self.left = None
# self.right = None
class Solution(object):
def findTilt(self, root):
"""
:type root: TreeNode
:rtype: int
"""
def calcSum(n):
ans = 0
if not n:
return 0
stack = [n]
while stack:
node = stack.pop()
if node:
ans += node.val
if node.left:stack.append(node.left)
if node.right:stack.append(node.right)
return ans
def calcTilt(n):
if not n:
return 0
return abs(calcSum(n.left) - calcSum(n.right))
stack_ = [root]
sum_ = 0
while stack_:
node_ = stack_.pop()
if node_:
sum_ += calcTilt(node_)
if node_.left:stack_.append(node_.left)
if node_.right:stack_.append(node_.right)
return sum_
大神的代码:感觉和树有关的很多很好的办法都用递归
def findTilt(self, root):
def tilt(root):
# return (sum, tilt) of tree
if not root: return (0, 0)
left = tilt(root.left)
right = tilt(root.right)
return (left[0] + right[0] + root.val, abs(left[0] - right[0]) + left[1] + right[1])
return tilt(root)[1]
这段代码让我觉得我完全没摸到递归的门路,我的代码会重复计算很多子节的和,这种避免了重复
def findTilt(self, root):
self.ans = 0
def _sum(node):
if not node: return 0
left, right = _sum(node.left), _sum(node.right)
self.ans += abs(left - right)
return node.val + left + right
_sum(root)
return self.ans
继续大神的代码:
def findTilt(self, root):
"""
:type root: TreeNode
:rtype: int
"""
if not root:
return 0
def csum(root):
if not root:
return 0
return root.val+csum(root.left)+csum(root.right)
return abs(csum(root.left)-csum(root.right))+self.findTilt(root.left)+self.findTilt(root.right)
671. Second Minimum Node In a Binary Tree
求整个二叉树中第二小的数,ac后看了别人的代码才发现题目没看完全,这个树每个节点要么有2个子节点要么没有子节点,而且子节点的值必定比节点值大
Example 1:
Input: 2 / \ 2 5 / \ 5 7 Output: 5 Explanation: The smallest value is 2, the second smallest value is 5.
Example 2:
Input: 2 / \ 2 2 Output: -1 Explanation: The smallest value is 2, but there isn't any second smallest value.
我的代码:
# Definition for a binary tree node.
# class TreeNode(object):
# def __init__(self, x):
# self.val = x
# self.left = None
# self.right = None
class Solution(object):
def findSecondMinimumValue(self, root):
"""
:type root: TreeNode
:rtype: int
"""
if not root:
return -1
stack = [root]
nums = set()
while stack:
node = stack.pop()
if node:
nums.add(node.val)
if node.left:stack.append(node.left)
if node.right:stack.append(node.right)
nums.remove(min(nums))
return min(nums) if nums else -1
大神的代码:我发现这个叫awice的人很厉害
Say the value of the root is min1
. If some node’s value is larger, it might be the answer, but every descendant node will be at least as big, so we don’t need to check them.
def findSecondMinimumValue(self, root):
self.ans = float('inf') #float('inf')表示正无穷
min1 = root.val
def dfs(node):
if node:
if min1 < node.val < self.ans:
self.ans = node.val
elif node.val == min1:
dfs(node.left)
dfs(node.right)
dfs(root)
return self.ans if self.ans < float('inf') else -1
还有一个叫Yangshun的,不过他的还没上面的好
class Solution(object):
def findSecondMinimumValue(self, root):
res = [float('inf')]
def traverse(node):
if not node:
return
if root.val < node.val < res[0]:
res[0] = node.val
traverse(node.left)
traverse(node.right)
traverse(root)
return -1 if res[0] == float('inf') else res[0]
482
.
License Key Formatting
按要求转化字符
Input: S = "5F3Z-2e-9-w", K = 4 Output: "5F3Z-2E9W" Explanation: The string S has been split into two parts, each part has 4 characters. Note that the two extra dashes are not needed and can be removed.
Example 2:
Input: S = "2-5g-3-J", K = 2 Output: "2-5G-3J" Explanation: The string S has been split into three parts, each part has 2 characters except the first part as it could be sh我的代码:
class Solution(object):
def licenseKeyFormatting(self, S, K):
"""
:type S: str
:type K: int
:rtype: str
"""
S = ''.join(re.split(r'\-',S)).upper()
ans = ''
count = 0
for i in S[::-1]:
if count % K != 0:
ans = i + ans
else:
ans = i + '-' + ans
count += 1
return ans.strip('-')
其他代码:都是按着顺序来,否者会有超时
class Solution(object):
def licenseKeyFormatting(self, S, K):
"""
:type S: str
:type K: int
:rtype: str
"""
S = S.upper().replace('-','')
size = len(S)
s1 = K if size%K==0 else size%K
res = S[:s1]
while s1<size:
res += '-'+S[s1:s1+K]
s1 += K
return res
有个正则表达式的:
class Solution(object):
def licenseKeyFormatting(self, S, K):
"""
:type S: str
:type K: int
:rtype: str
"""
formatted = S.replace("-","",len(S)).upper()[::-1]
formatted = re.sub(r'(\\w{' + str(K) + r'})', r'\\1-', formatted)
formatted = formatted[::-1]
formatted = re.sub(r'^-',r'', formatted)
return formatted
530
.
Minimum Absolute Difference in BST