def sortedListToBST(self, head: ListNode) -> TreeNode: """ :param nums: 从小到大排好序了 """ if not head: return None if not head.next: return TreeNode(head.val) slow = head fast = head.next.next while fast and fast.next: slow = slow.next fast = fast.next.next mid = slow # 从 mid 开始截断,这样后面再传 head 就相当于只传前半段 tmp = mid.next mid.next = None root = TreeNode(tmp.val) root.left = self.sortedListToBST(head) root.right = self.sortedListToBST(tmp.next) return root
def sortedListToBST(self, head: ListNode) -> TreeNode: # 空列表 return if head is None: return None # 单节点 return if head.next is None: return TreeNode(head.val) # 2个节点 return if head.next and head.next.next is None: root = TreeNode(head.next.val) root.left = TreeNode(head.val) return root # 快慢指针,快指针到终点时,慢指针正好是中点 prev = fast = slow = head while True: if fast.next: fast = fast.next else: break if fast.next: fast = fast.next else: break if slow.next: prev = slow slow = slow.next # 断开链接到中点的link prev.next = None root = TreeNode(slow.val) # 递归生成子树 root.left = self.sortedListToBST(head) root.right = self.sortedListToBST(slow.next) return root
def test_countNodes(self): from solution_0222 import Solution from utils import TreeNode solution = Solution() root = TreeNode(1, TreeNode(2), TreeNode(3)) root.left.add_left(4) root.left.add_right(5) root.right.add_left(6) self.assertEqual(solution.countNodes(root), 6)
def test_solution(): s = Solution() tree1 = TreeNode(1, TreeNode(3, TreeNode(5)), TreeNode(2)) tree2 = TreeNode(2, TreeNode(1, None, TreeNode(4)), TreeNode(3, None, TreeNode(7))) tree3 = s.mergeTrees(tree1, tree2) print(tree3)
def test_solution(): s = Solution() assert s.isSameTree(tree, tree) == True p = TreeNode(1, TreeNode(2), TreeNode(3)) q = TreeNode(1, TreeNode(2), TreeNode(3)) assert s.isSameTree(p, q) == True p = TreeNode(1, TreeNode(2)) p = TreeNode(1, None, TreeNode(2)) assert s.isSameTree(p, q) == False
def test_inorder_traversal(self): # 1 # \ # 2 # / # 3 root = TreeNode(1) root.right = TreeNode(2) root.right.left = TreeNode(3) self.assertListEqual([1, 3, 2], inorder_traversal_recursive(root)) self.assertListEqual([1, 3, 2], inorder_traversal_iterative(root))
def op(start, end): if start == end: return TreeNode(nums[start]) elif end - start == 1: root = TreeNode(nums[start]) root.right = TreeNode(nums[end]) return root else: pivot = (start + end) / 2 root = TreeNode(nums[pivot]) root.left = op(start, pivot - 1) root.right = op(pivot + 1, end) return root
def test_findTilt(): t1 = TreeNode(1) t2 = TreeNode(2) t3 = TreeNode(3) t1.left = t2 t1.right = t3 assert findTilt(t1) == 1, findTilt(t1) t4 = TreeNode(4) t5 = TreeNode(5) t2.left = t4 t3.left = t5 assert findTilt(t1) == 11, findTilt(t1)
def buildTree(self, preorder: List[int], inorder: List[int]) -> TreeNode: if not preorder: return None if len(preorder) == 1: return TreeNode(preorder[0]) root = TreeNode(preorder[0]) index = inorder.index(root.val) left_inorder = inorder[0:index] right_inorder = inorder[index + 1:] left_preorder = preorder[1:index + 1] right_preorder = preorder[index + 1:] root.left = self.buildTree(left_preorder, left_inorder) root.right = self.buildTree(right_preorder, right_inorder) return root
def buildTree(self, inorder: List[int], postorder: List[int]) -> TreeNode: if not inorder: return None if len(inorder) == 1: return TreeNode(inorder[0]) root = TreeNode(postorder[-1]) index = inorder.index(root.val) left_inorder = inorder[0:index] right_inorder = inorder[index + 1:] left_post_order = postorder[0:index] right_post_order = postorder[index:-1] root.left = self.buildTree(left_inorder, left_post_order) root.right = self.buildTree(right_inorder, right_post_order) return root
def test_binaryTreePaths(self): from solution_0257 import Solution from utils import TreeNode solution = Solution() root1 = TreeNode(1, TreeNode("2"), TreeNode("3")) root1.left.right = TreeNode("5") root2 = TreeNode("1") self.assertListEqual(solution.binaryTreePaths(root1), ["1->2->5", "1->3"]) self.assertListEqual(solution.binaryTreePaths(root2), ["1"])
def test_solution(): tree = TreeNode(5, TreeNode(4, TreeNode(11, TreeNode(7), TreeNode(2))), TreeNode(8, TreeNode(13), TreeNode(4, TreeNode(1)))) print(tree) s = Solution() assert s.hasPathSum(tree, 22) == False
def sortedArrayToBST(self, nums: List[int]) -> TreeNode: """ :param nums: 从小大大排好序了 """ if not nums or not len(nums): return None if len(nums) == 1: return TreeNode(nums[0]) mid = (0 + len(nums)) // 2 root = TreeNode(nums[mid]) root.left = self.sortedArrayToBST(nums[:mid]) root.right = self.sortedArrayToBST(nums[mid + 1:]) return root
def deserialize(self, data): """Decodes your encoded data to tree. :type data: str :rtype: TreeNode """ tokens = data.split(',') nodes = dict() for token in tokens: idx, val = token.split(':') nodes[int(idx)] = TreeNode(int(val)) if val != '' else None for idx in sorted(nodes.keys()): if nodes[idx] is None: continue li = 2 * idx + 1 ri = 2 * idx + 2 if li in nodes: nodes[idx].left = nodes[li] if ri in nodes: nodes[idx].right = nodes[ri] return nodes[0]
def buildTree(preorder: 'list[int]', inorder: 'list[int]') -> TreeNode: if inorder: ind = inorder.index(preorder.pop(0)) root = TreeNode(inorder[ind]) root.left = buildTree(preorder, inorder[0:ind]) root.right = buildTree(preorder, inorder[ind + 1:]) return root
def helper(s): cur = next(s) if cur == "#": return node = TreeNode(cur) node.left = helper(s) node.right = helper(s) return node
def node_from_preorder(p_i: int, p_j: int) -> TreeNode: """ p_i and p_j is left and right bounds for preorder list If bounds not valid (list not empty) -> return null Create node from left element in preorder With binary search search for first element which index in inorder is greater than node's Link node created with bounds p_i + 1 (miss first element) and left as left child Link node created with bound left and p_j as right child Return node """ if p_i >= p_j: return None node = TreeNode(preorder[p_i]) left, right = p_i + 1, p_j - 1 while left <= right: mid = (left + right) // 2 if indices[preorder[mid]][1] > indices[node.val][1]: right = mid - 1 else: left = mid + 1 node.left = node_from_preorder(p_i + 1, left) node.right = node_from_preorder(left, p_j) return node
def build(stop): if inorder and inorder[-1] != stop: root = TreeNode(preorder.pop()) root.left = build(root.val) inorder.pop() root.right = build(stop) return root
def sortedArrayToBST(self, nums: List[int]) -> TreeNode: if len(nums) == 0: return None i = (len(nums) - 1) // 2 root = TreeNode(nums[i]) root.left = self.sortedArrayToBST(nums[:i]) root.right = self.sortedArrayToBST(nums[i + 1:]) return root
def help(nums, l, h): m = (l + h) // 2 node = TreeNode(nums[m]) if l <= m - 1: node.left = help(nums, l, m - 1) if m + 1 <= h: node.right = help(nums, m + 1, h) return node
def initialize(self): """ Makes the frequency dict, list and encoding tree.""" self.freq_dict = self._mk_freq_dict() self.freq_list = list() for word in self.freq_dict: self.freq_list.append(TreeNode(self.freq_dict[word], content=word)) self.encode_tree = self._mk_encode_tree() self.encode_dict = self._mk_encode_dict()
def deserialize_tree_util(nodes): val = nodes.pop() if val == '$': return None root = TreeNode(int(val)) root.left = deserialize_tree_util(nodes) root.right = deserialize_tree_util(nodes) return root
def buildTree(self, preorder: List[int], inorder: List[int]) -> TreeNode: if len(preorder) == 0: return None mid = inorder.index(preorder[0]) t = TreeNode(preorder[0]) t.left = self.buildTree(preorder[1:mid + 1], inorder[:mid]) t.right = self.buildTree(preorder[mid + 1:], inorder[mid + 1:]) return t
def min_height_bst_from_sorted_array(A): if not A: return None mid = len(A) / 2 root = TreeNode(A[mid]) root.left = min_height_bst_from_sorted_array(A[:mid]) root.right = min_height_bst_from_sorted_array(A[mid + 1:]) return root
def sorted_array2bst(nums): if not nums: return None mid = len(nums) // 2 root = TreeNode(nums[mid]) root.left = sorted_array2bst(nums[:mid]) root.right = sorted_array2bst(nums[mid+1:]) return root
def addToTree(arr, start, end): if end < start: return None mid = (start + end) // 2 n = TreeNode(arr[mid]) n.left = addToTree(arr, start, mid - 1) n.right = addToTree(arr, mid + 1, end) return n
def sortedArrayToBST(self, nums: List[int]): if not nums: return mid = len(nums) // 2 root = TreeNode(nums[mid]) root.left = self.sortedArrayToBST(nums[:mid]) root.right = self.sortedArrayToBST(nums[mid + 1:]) return root
def recoverFromPreorder(self, S: str) -> TreeNode: # AC 思路如下: # 保存每一层的节点,由于是深度遍历,父节点必定是上一层的最后一个。 # 依次遍历得到深度和数值, # 根据深度得到父节点,如果父节点的左节点为空,赋值给左节点,否则给右节点 if not S: return None root = None stacks = [] depth = 0 num_str = '' for c in S: if c == '-': if num_str: new_node = TreeNode(int(num_str)) if not stacks: root = new_node stacks.append([root]) else: father_node = stacks[depth - 1][-1] if father_node.left is None: father_node.left = new_node else: father_node.right = new_node if len(stacks) < depth + 1: stacks.append([new_node]) else: stacks[depth].append(new_node) depth = 1 num_str = '' else: depth += 1 else: num_str += c new_node = TreeNode(int(num_str)) if root is None: return new_node father_node = stacks[depth - 1][-1] if father_node.left is None: father_node.left = new_node else: father_node.right = new_node return root
def dfs(low, high): if low > high: return [None] trees = [] for i in range(low, high + 1): left_set = dfs(low, i - 1) right_set = dfs(i + 1, high) trees += [TreeNode(i, left, right) for left in left_set for right in right_set] return trees
def buildTree(postorder, inorder): if not postorder or not inorder: return None tree_val = postorder[-1] root = TreeNode(tree_val) left_index = inorder.index(tree_val) root.left = buildTree(postorder[:left_index], inorder[:left_index]) root.right = buildTree(postorder[left_index:-1], inorder[left_index + 1:]) return root