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))