return False
if t.val != arr[cur_lev]:
return False
else:
if cur_lev == le - 1:
if not t.left and not t.right:
return True
else:
return False
else:
left = get_lef(t.left, cur_lev + 1)
if not left:
right = get_lef(t.right, cur_lev + 1)
return right
else:
return True
return get_lef(root, 0)
root = '[0,1,0,0,1,0,null,null,1,0,0]'
tree = stringToTreeNode(root)
arr = [0, 1, 1]
t1 = datetime.now()
s = Solution()
print(s.isValidSequence(tree, arr))
t2 = datetime.now()
print(t2 - t1)
'''
class Solution:
def pseudoPalindromicPaths(self, root: TreeNode) -> int:
lst, res = [0] * 10, 0
def get_num_of_palindromic(node: TreeNode):
nonlocal res
# 是叶子节点
lst[node.val] ^= 1
if not node.left and not node.right:
res += 1 if lst.count(1) < 2 else 0
else:
if node.left: get_num_of_palindromic(node.left)
if node.right: get_num_of_palindromic(node.right)
lst[node.val] ^= 1
get_num_of_palindromic(root)
return res
arr1 = '[2,1,1,1,3,null,null,null,null,null,1]'
root = stringToTreeNode(arr1)
t1 = datetime.now()
s = Solution()
print(s.pseudoPalindromicPaths(root))
t2 = datetime.now()
print(t2 - t1)
from collections import defaultdict, deque
from random import randint
from typing import List
from bisect import bisect_left, bisect, insort
from itertools import accumulate
import operator
from leecode.common.common_class import TreeNode
from leecode.common.official import stringToTreeNode
class Solution:
def searchBST(self, root: TreeNode, val: int) -> TreeNode:
if not root:
return None
if root.val == val:
return root
return self.searchBST(root.left,
val) if val < root.val else self.searchBST(
root.right, val)
string = "[4,2,7,1,3]"
root = stringToTreeNode(string)
val = 2
s1 = Solution()
t = s1.searchBST(root, val)
print(t)
from collections import Counter
from datetime import datetime
from typing import List
from leecode.common.common_class import TreeNode
from leecode.common.official import stringToTreeNode
class Solution:
def invertTree(self, root: TreeNode) -> TreeNode:
if not root:
return
if not root.left and not root.right:
return root
root.left, root.right = root.right, root.left
self.invertTree(root.left)
self.invertTree(root.right)
return root
# str1 = '[1,2,3,null,4,5,6]'
# str1 = '[4,2,7,1,3,6,9]'
str1 = '[4]'
tree = stringToTreeNode(str1)
t1 = datetime.now()
s1 = Solution()
print(s1.invertTree(tree))
t2 = datetime.now()
print(t2 - t1)
from typing import List
from bisect import bisect_left, insort
from leecode.common.common_class import TreeNode
from leecode.common.official import stringToTreeNode
class Solution:
def countNodes(self, root: TreeNode) -> int:
return 0 if not root \
else 1 + self.countNodes(root.left) + self.countNodes(root.right)
# nums = '[1,2,3,4,5,6]'
nums = '[1, 1, 1, 2, 0, 1, 99]'
tree = stringToTreeNode(nums)
so = Solution()
print(so.countNodes(tree))
# Definition for a binary tree node.
# class TreeNode:
# def __init__(self, x):
# self.val = x
# self.left = None
# self.right = None
from leecode.common.official import stringToTreeNode, TreeNode
class Solution:
def searchBST(self, root: TreeNode, val: int) -> TreeNode:
while True:
if not root:
return None
if val == root.val:
return root
elif val < root.val:
root = root.left
else:
root = root.right
lst = '[4, 2, 7, 1, 3]'
root = stringToTreeNode(lst)
s = Solution()
r = s.searchBST(root, 5)
print('--------')
def get_sumof_node(self, node: TreeNode, lst: list):
le = len(lst)
sums = 0
for i in range(le):
lst[i] += 1
if node.val % 2 == 0:
lst.append(0)
if lst.count(2) > 0:
sums += node.val
if node.left:
sums += self.get_sumof_node(node.left, lst)
if node.right:
sums += self.get_sumof_node(node.right, lst)
if len(lst) > 0:
if lst[-1] == 0:
lst.pop()
for i in range(le):
lst[i] -= 1
return sums
t1 = datetime.now()
s = Solution()
root1 = '[6,7,8,2,7,1,3,9,null,1,4,null,null,null,5]'
node = stringToTreeNode(root1)
print(s.sumEvenGrandparent(node))
t2 = datetime.now()
print(t2 - t1)
return t2
elif t2 is None:
# node.right = self.build_tree(t1.left, None)
# node.right = self.build_tree(t1.left, None)
# node.left = t1
return t1
else:
node.left = self.build_tree(t1.left, t2.left)
node.right = self.build_tree(t1.right, t2.right)
return node
else:
return None
# t1 = buildTree([1, 3, 2, 5])
# t2 = buildTree([2, 1, 3, None, 4, None, 7])
# t1 = buildTree([3, 4, 5, 1, 2, None, None, 0])
# t2 = buildTree([4, 1, 2])
# t1 = buildTree([1, 2, None, 3])
# t2 = buildTree([1, None, 2, None, None, None, 3])
t1 = stringToTreeNode('[1,2,null,3]')
t2 = stringToTreeNode('[4,null,7,null,8]')
so = Solution()
r = so.mergeTrees(t1, t2)
print('---------')
sums, _ = self.get_sum(root, 1)
return sums
def get_sum(self, node: TreeNode, dept: int):
left_sum, right_sum = 0, 0
if node.left is None and node.right is None:
return (node.val, dept)
else:
dep_left, dep_right = 0, 0
if node.left:
left_sum, dep_left = self.get_sum(node.left, dept + 1)
if node.right:
right_sum, dep_right = self.get_sum(node.right, dept + 1)
if dep_left > dep_right:
return (left_sum, dep_left)
elif dep_left < dep_right:
return (right_sum, dep_right)
else:
return (left_sum + right_sum, dep_left)
node = '[1,2,3,4,5,null,6,7,null,null,null,null,8]'
root = stringToTreeNode(node)
t1 = datetime.now()
s = Solution()
print(s.deepestLeavesSum(root))
t2 = datetime.now()
print(t2 - t1)
from leecode.common.official import stringToTreeNode
from leecode.common.common_class import TreeNode
from datetime import datetime
class Solution:
def diameterOfBinaryTree(self, root: TreeNode) -> int:
maxlen = 0
def get_level(r: TreeNode) -> int:
nonlocal maxlen
if not r: return 0
# 左子树和右子树深度
left_level, right_level = get_level(r.left), get_level(r.right)
maxlen = max(left_level + right_level, maxlen)
return max(left_level, right_level) + 1
get_level(root)
return maxlen
# arr = '[1,2,3,4,5]'
arr = '[1,2,3,4,5]'
t = stringToTreeNode(arr)
t1 = datetime.now()
s = Solution()
print(s.diameterOfBinaryTree(t))
t2 = datetime.now()
print(t2 - t1)
def maxLevelSum(self, root: TreeNode) -> int:
level = 1
dic = defaultdict(int)
dic[level] = root.val
def cal_sum(node: TreeNode, lev: int):
if node:
dic[lev + 1] += node.val
cal_sum(node.left, lev + 1)
cal_sum(node.right, lev + 1)
cal_sum(root.left, level)
cal_sum(root.right, level)
ret = 0
val = np.iinfo(np.int).min
# for index, v in enumerate(list(accumulate(dic.values(), add))):
for k, v in dic.items():
if v > val:
val = v
ret = k
return ret
string = ' [1,7,0,7,-8,null,null]'
# string = '[989,null,10250,98693,-89388,null,null,null,-32127]'
node = stringToTreeNode(string)
s = Solution()
print(s.maxLevelSum(node))
name: ^(Flip Equivalent Binary Trees)
'''
class Solution:
def flipEquiv(self, root1: TreeNode, root2: TreeNode) -> bool:
if root1 is None and root2 is None:
return True
elif root1 and root2:
if root1.val == root2.val:
return (self.flipEquiv(root1.left, root2.left) and
(self.flipEquiv(root1.right, root2.right))) or (
self.flipEquiv(root1.left, root2.right) and
(self.flipEquiv(root1.right, root2.left)))
else:
return False
else:
return False
root1 = '[1,2,3,4,5,6,null,null,null,7,8]'
root2 = '[1,3,2,null,6,4,5,null,null,null,null,8,7]'
node1 = stringToTreeNode(root1)
node2 = stringToTreeNode(root2)
t1 = datetime.now()
s = Solution()
print(s.flipEquiv(node1, node2))
t2 = datetime.now()
print(t2 - t1)
class Solution:
def getTargetCopy(self, original: TreeNode, cloned: TreeNode,
target: TreeNode) -> TreeNode:
v = target.val
stacks = []
if cloned:
stacks.append(cloned)
while len(stacks) > 0:
poped = stacks.pop()
if poped.val == v:
return poped
if poped.right:
stacks.append(poped.right)
if poped.left:
stacks.append(poped.left)
return None
arr = '[1,2,3,4,5,6,7,8,9,10]'
original = stringToTreeNode(arr)
cloned = stringToTreeNode(arr)
target = TreeNode(5)
t1 = datetime.now()
s = Solution()
res = s.getTargetCopy(original, cloned, target)
print(res)
t2 = datetime.now()
print(t2 - t1)
def setUpClass(cls) -> None:
cls.node1 = stringToTreeNode('[]')
cls.node2 = stringToTreeNode('[1]')
cls.node3 = stringToTreeNode('[1,2]')
cls.node4 = stringToTreeNode('[1,2,null,3]')
cls.node5 = stringToTreeNode('[1,2,null,null,4]')
cls.node6 = stringToTreeNode('[1,2,null,3,4]')
cls.node7 = stringToTreeNode('[1,null,3]')
cls.node8 = stringToTreeNode('[1,null,3,4]')
cls.node9 = stringToTreeNode('[1,null,3,null,5]')
cls.node10 = stringToTreeNode('[1,2,3,4,5,6,7]')
cls.node11 = stringToTreeNode('[1,2,3,null,5,6]')
cls.node12 = stringToTreeNode('[1,2,3,4,null,null,7]')
cls.node13 = stringToTreeNode('[1,2,3,4,null,7,null]')
cls.node14 = stringToTreeNode('[1,2,3,null,4,null,6]')
r = TreeNode(lst[middle])
r.left = build_tree(lst[0:middle])
r.right = build_tree(lst[middle + 1:])
return r
res = []
stacks = []
if root:
stacks.append(root)
while len(stacks) > 0:
poped = stacks.pop()
res.append(poped.val)
if poped.right:
stacks.append(poped.right)
if poped.left:
stacks.append(poped.left)
res.sort()
tree = build_tree(res)
return tree
arr1 = '[2,1,3,null,null,null,4]'
tree = stringToTreeNode(arr1)
t1 = datetime.now()
s = Solution()
print(s.balanceBST(tree))
t2 = datetime.now()
print(t2 - t1)
def get_subtree(self, node: TreeNode):
if node is None:
return 0, None
t = TreeNode(node.val)
left_num, left_subtree = self.get_subtree(node.left)
right_num, right_subtree = self.get_subtree(node.right)
if left_num > 0 or right_num > 0:
if left_num > 0:
t.left = left_subtree
if right_num > 0:
t.right = right_subtree
return 1, t
else:
if t.val > 0:
return 1, t
else:
return 0, None
# tree = '[0]'
tree = '[1,0,1,0,0,0,1]'
tree = '[1,1,0,1,1,0,1,0]'
root1 = stringToTreeNode(tree)
s = Solution()
s.pruneTree(root1)
print('----')
if root.right:
self.get_sumof_node_and_val(root.right)
return Solution.sum
# get both sum of number of node and sum of val
def get_sumof_node_and_val(self, node: TreeNode):
if node.left is None and node.right is None:
Solution.sum += abs(node.val - 1)
return node.val, 1
else:
left_sum_of_val = 0
left_sum_of_node = 0
right_sum_of_val = 0
right_sum_of_node = 0
if node.left is not None:
left_sum_of_val, left_sum_of_node = self.get_sumof_node_and_val(node.left)
if node.right is not None:
right_sum_of_val, right_sum_of_node = self.get_sumof_node_and_val(node.right)
Solution.sum += abs(
(left_sum_of_val + right_sum_of_val + node.val) -
(left_sum_of_node + right_sum_of_node + 1))
return left_sum_of_val + right_sum_of_val + node.val, left_sum_of_node + right_sum_of_node + 1
lst = '[0,0,0,0,4,2,0,null,null,0,null,null,3]'
node = stringToTreeNode(lst)
s = Solution()
print(s.distributeCoins(node))
from leecode.common.official import stringToTreeNode
class Solution:
def leafSimilar(self, root1: TreeNode, root2: TreeNode) -> bool:
return self.get_lst(root1) == self.get_lst(root2)
def get_lst(self, node: TreeNode):
ret_lst = []
stacks = [node]
while len(stacks) > 0:
poped = stacks.pop()
if poped.left is None and poped.right is None:
ret_lst.append(poped.val)
else:
if poped.right is not None:
stacks.append(poped.right)
if poped.left is not None:
stacks.append(poped.left)
return ret_lst
s1 = '[3,5,1,6,2,9,8,null,null,7,4]'
s2 = '[3,5,1,6,7,4,2,null,null,null,null,null,null,9,8]'
root1 = stringToTreeNode(s1)
root2 = stringToTreeNode(s2)
s = Solution()
print(s.leafSimilar(root1, root2))
else:
node.right = tree
if node.left is None and node.right is None:
return (None, 1)
else:
return (node, 0)
else:
if node.left:
tree, is_need_delete = self.get_sub(node.left, target)
if is_need_delete == 1:
node.left = None
else:
node.left = tree
if node.right:
tree, is_need_delete = self.get_sub(node.right, target)
if is_need_delete == 1:
node.right = None
else:
node.right = tree
return (node, 0)
nodes = '[1,2,null,2,null,2]'
tar = 2
root1 = stringToTreeNode(nodes)
s = Solution()
res = s.removeLeafNodes(root1, tar)
print(1)
res.extend(list1[i:])
return res
def getList(self, node):
res = []
current = node
stacks = [] # initialize stack
while True:
if current is not None:
stacks.append(current)
current = current.left
elif stacks:
current = stacks.pop()
res.append(current.val)
current = current.right
else:
break
return res
s1 = "[2,1,4]"
s2 = "[1,0,3]"
node1 = stringToTreeNode(s1)
node2 = stringToTreeNode(s2)
s = Solution()
print(s.getAllElements(node1, node2))
