From 90eec976ebcbddf8c27f0cf7da4b61b1f4e944f2 Mon Sep 17 00:00:00 2001 From: yanglbme Date: Wed, 9 Aug 2023 19:55:53 +0800 Subject: [PATCH] feat: add solutions to lc problem: No.0105 No.0105.Construct Binary Tree from Preorder and Inorder Traversal --- .../README.md | 316 +++++++++++++----- .../README_EN.md | 312 ++++++++++++----- .../Solution.cpp | 60 ++-- .../Solution.go | 17 +- .../Solution.java | 74 ++-- .../Solution.js | 24 +- .../Solution.py | 39 ++- .../Solution.rs | 80 ++--- .../Solution.ts | 25 +- .../0100-0199/0189.Rotate Array/README.md | 7 + .../0100-0199/0189.Rotate Array/README_EN.md | 7 + .../0100-0199/0189.Rotate Array/Solution.py | 16 +- 12 files changed, 632 insertions(+), 345 deletions(-) diff --git a/solution/0100-0199/0105.Construct Binary Tree from Preorder and Inorder Traversal/README.md b/solution/0100-0199/0105.Construct Binary Tree from Preorder and Inorder Traversal/README.md index f7365d7ac83e0..6aeaffa2e7672 100644 --- a/solution/0100-0199/0105.Construct Binary Tree from Preorder and Inorder Traversal/README.md +++ b/solution/0100-0199/0105.Construct Binary Tree from Preorder and Inorder Traversal/README.md @@ -52,7 +52,9 @@ > 前序遍历：先遍历根节点，再遍历左右子树；中序遍历：先遍历左子树，再遍历根节点，最后遍历右子树。 -时间复杂度 $O(n)$，空间复杂度 $O(n)$。 +时间复杂度 $O(n)$，空间复杂度 $O(n)$。其中 $n$ 为二叉树节点个数。 + +如果题目中给定的节点值存在重复，那么我们只需要记录每个节点值出现的所有位置，然后递归构建即可。 @@ -69,39 +71,40 @@ # self.right = right class Solution: def buildTree(self, preorder: List[int], inorder: List[int]) -> Optional[TreeNode]: - if not preorder: - return None - v = preorder[0] - root = TreeNode(val=v) - i = inorder.index(v) - root.left = self.buildTree(preorder[1 : 1 + i], inorder[:i]) - root.right = self.buildTree(preorder[1 + i :], inorder[i + 1 :]) - return root -``` - -```python -# Definition for a binary tree node. -# class TreeNode: -# def __init__(self, val=0, left=None, right=None): -# self.val = val -# self.left = left -# self.right = right -class Solution: - def buildTree(self, preorder: List[int], inorder: List[int]) -> Optional[TreeNode]: - def dfs(i, j, n): + def dfs(i: int, j: int, n: int): if n <= 0: return None v = preorder[i] k = d[v] - root = TreeNode(v) - root.left = dfs(i + 1, j, k - j) - root.right = dfs(i + 1 + k - j, k + 1, n - k + j - 1) - return root + l = dfs(i + 1, j, k - j) + r = dfs(i + 1 + k - j, k + 1, n - k + j - 1) + return TreeNode(v, l, r) d = {v: i for i, v in enumerate(inorder)} return dfs(0, 0, len(preorder)) ``` +```python +class Solution: + def getBinaryTrees(self, preOrder: List[int], inOrder: List[int]) -> List[TreeNode]: + def dfs(i: int, j: int, n: int) -> List[TreeNode]: + if n <= 0: + return [None] + v = preOrder[i] + ans = [] + for k in d[v]: + if j <= k < j + n: + for l in dfs(i + 1, j, k - j): + for r in dfs(i + 1 + k - j, k + 1, n - 1 - (k - j)): + ans.append(TreeNode(v, l, r)) + return ans + + d = defaultdict(list) + for i, x in enumerate(inOrder): + d[x].append(i) + return dfs(0, 0, len(preOrder)) +``` + ### **Java** @@ -123,25 +126,71 @@ class Solution: * } */ class Solution { - private Map indexes = new HashMap<>(); + private int[] preorder; + private int[] inorder; + private Map d = new HashMap<>(); public TreeNode buildTree(int[] preorder, int[] inorder) { - for (int i = 0; i < inorder.length; ++i) { - indexes.put(inorder[i], i); + int n = preorder.length; + this.preorder = preorder; + this.inorder = inorder; + for (int i = 0; i < n; ++i) { + d.put(inorder[i], i); } - return dfs(preorder, inorder, 0, 0, preorder.length); + return dfs(0, 0, n); } - private TreeNode dfs(int[] preorder, int[] inorder, int i, int j, int n) { + private TreeNode dfs(int i, int j, int n) { if (n <= 0) { return null; } int v = preorder[i]; - int k = indexes.get(v); - TreeNode root = new TreeNode(v); - root.left = dfs(preorder, inorder, i + 1, j, k - j); - root.right = dfs(preorder, inorder, i + 1 + k - j, k + 1, n - k + j - 1); - return root; + int k = d.get(v); + TreeNode l = dfs(i + 1, j, k - j); + TreeNode r = dfs(i + 1 + k - j, k + 1, n - 1 - (k - j)); + return new TreeNode(v, l, r); + } +} +``` + +```java +/** + * Definition for a binary tree node. + * public class TreeNode { + * int val; + * TreeNode left; + * TreeNode right; + * TreeNode() {} + * TreeNode(int val) { this.val = val; } + * TreeNode(int val, TreeNode left, TreeNode right) { + * this.val = val; + * this.left = left; + * this.right = right; + * } + * } + */ +class Solution { + private int[] preorder; + private Map d = new HashMap<>(); + + public TreeNode buildTree(int[] preorder, int[] inorder) { + int n = preorder.length; + this.preorder = preorder; + for (int i = 0; i < n; ++i) { + d.put(inorder[i], i); + } + return dfs(0, 0, n); + } + + private TreeNode dfs(int i, int j, int n) { + if (n <= 0) { + return null; + } + int v = preorder[i]; + int k = d.get(v); + TreeNode l = dfs(i + 1, j, k - j); + TreeNode r = dfs(i + 1 + k - j, k + 1, n - 1 - (k - j)); + return new TreeNode(v, l, r); } } ``` @@ -162,21 +211,68 @@ class Solution { */ class Solution { public: - unordered_map indexes; - TreeNode* buildTree(vector& preorder, vector& inorder) { - for (int i = 0; i < inorder.size(); ++i) indexes[inorder[i]] = i; - return dfs(preorder, inorder, 0, 0, inorder.size()); + int n = preorder.size(); + unordered_map d; + for (int i = 0; i < n; ++i) { + d[inorder[i]] = i; + } + function dfs = [&](int i, int j, int n) -> TreeNode* { + if (n <= 0) { + return nullptr; + } + int v = preorder[i]; + int k = d[v]; + TreeNode* l = dfs(i + 1, j, k - j); + TreeNode* r = dfs(i + 1 + k - j, k + 1, n - 1 - (k - j)); + return new TreeNode(v, l, r); + }; + return dfs(0, 0, n); } +}; +``` - TreeNode* dfs(vector& preorder, vector& inorder, int i, int j, int n) { - if (n <= 0) return nullptr; - int v = preorder[i]; - int k = indexes[v]; - TreeNode* root = new TreeNode(v); - root->left = dfs(preorder, inorder, i + 1, j, k - j); - root->right = dfs(preorder, inorder, i + 1 + k - j, k + 1, n - k + j - 1); - return root; +```cpp +/** + * struct TreeNode { + * int val; + * struct TreeNode *left; + * struct TreeNode *right; + * TreeNode(int x) : val(x), left(nullptr), right(nullptr) {} + * }; + */ +class Solution { +public: + vector getBinaryTrees(vector& preOrder, vector& inOrder) { + int n = inOrder.size(); + unordered_map> d; + for (int i = 0; i < n; ++i) { + d[inOrder[i]].push_back(i); + } + function(int, int, int)> dfs = [&](int i,int j, int n) -> vector { + vector ans; + if (n <= 0) { + ans.push_back(nullptr); + return ans; + } + int v = preOrder[i]; + for (int k : d[v]) { + if (k >= j && k < j + n) { + auto lefts = dfs(i + 1, j, k - j); + auto rights = dfs(i + 1 + k - j, k + 1, n - 1 - (k - j)); + for (TreeNode* l : lefts) { + for (TreeNode* r : rights) { + TreeNode* node = new TreeNode(v); + node->left = l; + node->right = r; + ans.push_back(node); + } + } + } + } + return ans; + }; + return dfs(0, 0, n); } }; ``` @@ -193,9 +289,9 @@ public: * } */ func buildTree(preorder []int, inorder []int) *TreeNode { - indexes := make(map[int]int) - for i, v := range inorder { - indexes[v] = i + d := map[int]int{} + for i, x := range inorder { + d[x] = i } var dfs func(i, j, n int) *TreeNode dfs = func(i, j, n int) *TreeNode { @@ -203,13 +299,44 @@ func buildTree(preorder []int, inorder []int) *TreeNode { return nil } v := preorder[i] - k := indexes[v] - root := &TreeNode{Val: v} - root.Left = dfs(i+1, j, k-j) - root.Right = dfs(i+1+k-j, k+1, n-k+j-1) - return root + k := d[v] + l := dfs(i+1, j, k-j) + r := dfs(i+1+k-j, k+1, n-1-(k-j)) + return &TreeNode{v, l, r} } - return dfs(0, 0, len(inorder)) + return dfs(0, 0, len(preorder)) +} +``` + +```go +func getBinaryTrees(preOrder []int, inOrder []int) []*TreeNode { + n := len(preOrder) + d := map[int][]int{} + for i, x := range inOrder { + d[x] = append(d[x], i) + } + var dfs func(i, j, n int) []*TreeNode + dfs = func(i, j, n int) []*TreeNode { + ans := []*TreeNode{} + if n <= 0 { + ans = append(ans, nil) + return ans + } + v := preOrder[i] + for _, k := range d[v] { + if k >= j && k < j+n { + lefts := dfs(i+1, j, k-j) + rights := dfs(i+1+k-j, k+1, n-1-(k-j)) + for _, left := range lefts { + for _, right := range rights { + ans = append(ans, &TreeNode{v, left, right}) + } + } + } + } + return ans + } + return dfs(0, 0, n) } ``` @@ -231,17 +358,22 @@ func buildTree(preorder []int, inorder []int) *TreeNode { */ function buildTree(preorder: number[], inorder: number[]): TreeNode | null { - const n = preorder.length; - if (n === 0) { - return null; + const d: Map = new Map(); + const n = inorder.length; + for (let i = 0; i < n; ++i) { + d.set(inorder[i], i); } - const val = preorder[0]; - const index = inorder.indexOf(val); - return new TreeNode( - val, - buildTree(preorder.slice(1, index + 1), inorder.slice(0, index)), - buildTree(preorder.slice(index + 1), inorder.slice(index + 1)), - ); + const dfs = (i: number, j: number, n: number): TreeNode | null => { + if (n <= 0) { + return null; + } + const v = preorder[i]; + const k = d.get(v)!; + const l = dfs(i + 1, j, k - j); + const r = dfs(i + 1 + k - j, k + 1, n - 1 - (k - j)); + return new TreeNode(v, l, r); + }; + return dfs(0, 0, n); } ``` @@ -268,22 +400,26 @@ function buildTree(preorder: number[], inorder: number[]): TreeNode | null { // } use std::rc::Rc; use std::cell::RefCell; +use std::collections::HashMap; impl Solution { - fn to_tree(preorder: &[i32], inorder: &[i32]) -> Option>> { - if preorder.is_empty() { - return None; + pub fn build_tree(preorder: Vec, inorder: Vec) -> Option>> { + let mut d = HashMap::new(); + for (i, &x) in inorder.iter().enumerate() { + d.insert(x, i); } - let val = preorder[0]; - let index = inorder.iter().position(|&v| v == val).unwrap(); - Some(Rc::new(RefCell::new(TreeNode { - val, - left: Self::to_tree(&preorder[1..index + 1], &inorder[..index]), - right: Self::to_tree(&preorder[index + 1..], &inorder[index + 1..]), - }))) + Self::dfs(&preorder, &d, 0, 0, preorder.len()) } - pub fn build_tree(preorder: Vec, inorder: Vec) -> Option>> { - Self::to_tree(&preorder[..], &inorder[..]) + pub fn dfs(preorder: &Vec, d: &HashMap, i: usize, j: usize, n: usize) -> Option>> { + if n <= 0 { + return None; + } + let v = preorder[i]; + let k = d[&v]; + let mut root = TreeNode::new(v); + root.left = Self::dfs(preorder, d, i + 1, j, k - j); + root.right = Self::dfs(preorder, d, i + k - j + 1, k + 1, n - k + j - 1); + Some(Rc::new(RefCell::new(root))) } } ``` @@ -305,22 +441,22 @@ impl Solution { * @return {TreeNode} */ var buildTree = function (preorder, inorder) { - function dfs(i, j, n) { + const d = new Map(); + const n = inorder.length; + for (let i = 0; i < n; ++i) { + d.set(inorder[i], i); + } + const dfs = (i, j, n) => { if (n <= 0) { return null; } const v = preorder[i]; - const k = d[v]; - const root = new TreeNode(v); - root.left = dfs(i + 1, j, k - j); - root.right = dfs(i + 1 + k - j, k + 1, n - k + j - 1); - return root; - } - const d = new Map(); - for (const [i, v] of inorder.entries()) { - d[v] = i; - } - return dfs(0, 0, inorder.length); + const k = d.get(v); + const l = dfs(i + 1, j, k - j); + const r = dfs(i + 1 + k - j, k + 1, n - 1 - (k - j)); + return new TreeNode(v, l, r); + }; + return dfs(0, 0, n); }; ``` diff --git a/solution/0100-0199/0105.Construct Binary Tree from Preorder and Inorder Traversal/README_EN.md b/solution/0100-0199/0105.Construct Binary Tree from Preorder and Inorder Traversal/README_EN.md index 1ee72589b9bf9..96fd98a357981 100644 --- a/solution/0100-0199/0105.Construct Binary Tree from Preorder and Inorder Traversal/README_EN.md +++ b/solution/0100-0199/0105.Construct Binary Tree from Preorder and Inorder Traversal/README_EN.md @@ -49,39 +49,40 @@ # self.right = right class Solution: def buildTree(self, preorder: List[int], inorder: List[int]) -> Optional[TreeNode]: - if not preorder: - return None - v = preorder[0] - root = TreeNode(val=v) - i = inorder.index(v) - root.left = self.buildTree(preorder[1 : 1 + i], inorder[:i]) - root.right = self.buildTree(preorder[1 + i :], inorder[i + 1 :]) - return root -``` - -```python -# Definition for a binary tree node. -# class TreeNode: -# def __init__(self, val=0, left=None, right=None): -# self.val = val -# self.left = left -# self.right = right -class Solution: - def buildTree(self, preorder: List[int], inorder: List[int]) -> Optional[TreeNode]: - def dfs(i, j, n): + def dfs(i: int, j: int, n: int): if n <= 0: return None v = preorder[i] k = d[v] - root = TreeNode(v) - root.left = dfs(i + 1, j, k - j) - root.right = dfs(i + 1 + k - j, k + 1, n - k + j - 1) - return root + l = dfs(i + 1, j, k - j) + r = dfs(i + 1 + k - j, k + 1, n - k + j - 1) + return TreeNode(v, l, r) d = {v: i for i, v in enumerate(inorder)} return dfs(0, 0, len(preorder)) ``` +```python +class Solution: + def getBinaryTrees(self, preOrder: List[int], inOrder: List[int]) -> List[TreeNode]: + def dfs(i: int, j: int, n: int) -> List[TreeNode]: + if n <= 0: + return [None] + v = preOrder[i] + ans = [] + for k in d[v]: + if j <= k < j + n: + for l in dfs(i + 1, j, k - j): + for r in dfs(i + 1 + k - j, k + 1, n - 1 - (k - j)): + ans.append(TreeNode(v, l, r)) + return ans + + d = defaultdict(list) + for i, x in enumerate(inOrder): + d[x].append(i) + return dfs(0, 0, len(preOrder)) +``` + ### **Java** ```java @@ -101,25 +102,71 @@ class Solution: * } */ class Solution { - private Map indexes = new HashMap<>(); + private int[] preorder; + private int[] inorder; + private Map d = new HashMap<>(); + + public TreeNode buildTree(int[] preorder, int[] inorder) { + int n = preorder.length; + this.preorder = preorder; + this.inorder = inorder; + for (int i = 0; i < n; ++i) { + d.put(inorder[i], i); + } + return dfs(0, 0, n); + } + + private TreeNode dfs(int i, int j, int n) { + if (n <= 0) { + return null; + } + int v = preorder[i]; + int k = d.get(v); + TreeNode l = dfs(i + 1, j, k - j); + TreeNode r = dfs(i + 1 + k - j, k + 1, n - 1 - (k - j)); + return new TreeNode(v, l, r); + } +} +``` + +```java +/** + * Definition for a binary tree node. + * public class TreeNode { + * int val; + * TreeNode left; + * TreeNode right; + * TreeNode() {} + * TreeNode(int val) { this.val = val; } + * TreeNode(int val, TreeNode left, TreeNode right) { + * this.val = val; + * this.left = left; + * this.right = right; + * } + * } + */ +class Solution { + private int[] preorder; + private Map d = new HashMap<>(); public TreeNode buildTree(int[] preorder, int[] inorder) { - for (int i = 0; i < inorder.length; ++i) { - indexes.put(inorder[i], i); + int n = preorder.length; + this.preorder = preorder; + for (int i = 0; i < n; ++i) { + d.put(inorder[i], i); } - return dfs(preorder, inorder, 0, 0, preorder.length); + return dfs(0, 0, n); } - private TreeNode dfs(int[] preorder, int[] inorder, int i, int j, int n) { + private TreeNode dfs(int i, int j, int n) { if (n <= 0) { return null; } int v = preorder[i]; - int k = indexes.get(v); - TreeNode root = new TreeNode(v); - root.left = dfs(preorder, inorder, i + 1, j, k - j); - root.right = dfs(preorder, inorder, i + 1 + k - j, k + 1, n - k + j - 1); - return root; + int k = d.get(v); + TreeNode l = dfs(i + 1, j, k - j); + TreeNode r = dfs(i + 1 + k - j, k + 1, n - 1 - (k - j)); + return new TreeNode(v, l, r); } } ``` @@ -140,21 +187,68 @@ class Solution { */ class Solution { public: - unordered_map indexes; - TreeNode* buildTree(vector& preorder, vector& inorder) { - for (int i = 0; i < inorder.size(); ++i) indexes[inorder[i]] = i; - return dfs(preorder, inorder, 0, 0, inorder.size()); + int n = preorder.size(); + unordered_map d; + for (int i = 0; i < n; ++i) { + d[inorder[i]] = i; + } + function dfs = [&](int i, int j, int n) -> TreeNode* { + if (n <= 0) { + return nullptr; + } + int v = preorder[i]; + int k = d[v]; + TreeNode* l = dfs(i + 1, j, k - j); + TreeNode* r = dfs(i + 1 + k - j, k + 1, n - 1 - (k - j)); + return new TreeNode(v, l, r); + }; + return dfs(0, 0, n); } +}; +``` - TreeNode* dfs(vector& preorder, vector& inorder, int i, int j, int n) { - if (n <= 0) return nullptr; - int v = preorder[i]; - int k = indexes[v]; - TreeNode* root = new TreeNode(v); - root->left = dfs(preorder, inorder, i + 1, j, k - j); - root->right = dfs(preorder, inorder, i + 1 + k - j, k + 1, n - k + j - 1); - return root; +```cpp +/** + * struct TreeNode { + * int val; + * struct TreeNode *left; + * struct TreeNode *right; + * TreeNode(int x) : val(x), left(nullptr), right(nullptr) {} + * }; + */ +class Solution { +public: + vector getBinaryTrees(vector& preOrder, vector& inOrder) { + int n = inOrder.size(); + unordered_map> d; + for (int i = 0; i < n; ++i) { + d[inOrder[i]].push_back(i); + } + function(int, int, int)> dfs = [&](int i,int j, int n) -> vector { + vector ans; + if (n <= 0) { + ans.push_back(nullptr); + return ans; + } + int v = preOrder[i]; + for (int k : d[v]) { + if (k >= j && k < j + n) { + auto lefts = dfs(i + 1, j, k - j); + auto rights = dfs(i + 1 + k - j, k + 1, n - 1 - (k - j)); + for (TreeNode* l : lefts) { + for (TreeNode* r : rights) { + TreeNode* node = new TreeNode(v); + node->left = l; + node->right = r; + ans.push_back(node); + } + } + } + } + return ans; + }; + return dfs(0, 0, n); } }; ``` @@ -171,9 +265,9 @@ public: * } */ func buildTree(preorder []int, inorder []int) *TreeNode { - indexes := make(map[int]int) - for i, v := range inorder { - indexes[v] = i + d := map[int]int{} + for i, x := range inorder { + d[x] = i } var dfs func(i, j, n int) *TreeNode dfs = func(i, j, n int) *TreeNode { @@ -181,13 +275,44 @@ func buildTree(preorder []int, inorder []int) *TreeNode { return nil } v := preorder[i] - k := indexes[v] - root := &TreeNode{Val: v} - root.Left = dfs(i+1, j, k-j) - root.Right = dfs(i+1+k-j, k+1, n-k+j-1) - return root + k := d[v] + l := dfs(i+1, j, k-j) + r := dfs(i+1+k-j, k+1, n-1-(k-j)) + return &TreeNode{v, l, r} } - return dfs(0, 0, len(inorder)) + return dfs(0, 0, len(preorder)) +} +``` + +```go +func getBinaryTrees(preOrder []int, inOrder []int) []*TreeNode { + n := len(preOrder) + d := map[int][]int{} + for i, x := range inOrder { + d[x] = append(d[x], i) + } + var dfs func(i, j, n int) []*TreeNode + dfs = func(i, j, n int) []*TreeNode { + ans := []*TreeNode{} + if n <= 0 { + ans = append(ans, nil) + return ans + } + v := preOrder[i] + for _, k := range d[v] { + if k >= j && k < j+n { + lefts := dfs(i+1, j, k-j) + rights := dfs(i+1+k-j, k+1, n-1-(k-j)) + for _, left := range lefts { + for _, right := range rights { + ans = append(ans, &TreeNode{v, left, right}) + } + } + } + } + return ans + } + return dfs(0, 0, n) } ``` @@ -209,17 +334,22 @@ func buildTree(preorder []int, inorder []int) *TreeNode { */ function buildTree(preorder: number[], inorder: number[]): TreeNode | null { - const n = preorder.length; - if (n === 0) { - return null; + const d: Map = new Map(); + const n = inorder.length; + for (let i = 0; i < n; ++i) { + d.set(inorder[i], i); } - const val = preorder[0]; - const index = inorder.indexOf(val); - return new TreeNode( - val, - buildTree(preorder.slice(1, index + 1), inorder.slice(0, index)), - buildTree(preorder.slice(index + 1), inorder.slice(index + 1)), - ); + const dfs = (i: number, j: number, n: number): TreeNode | null => { + if (n <= 0) { + return null; + } + const v = preorder[i]; + const k = d.get(v)!; + const l = dfs(i + 1, j, k - j); + const r = dfs(i + 1 + k - j, k + 1, n - 1 - (k - j)); + return new TreeNode(v, l, r); + }; + return dfs(0, 0, n); } ``` @@ -246,22 +376,26 @@ function buildTree(preorder: number[], inorder: number[]): TreeNode | null { // } use std::rc::Rc; use std::cell::RefCell; +use std::collections::HashMap; impl Solution { - fn to_tree(preorder: &[i32], inorder: &[i32]) -> Option>> { - if preorder.is_empty() { - return None; + pub fn build_tree(preorder: Vec, inorder: Vec) -> Option>> { + let mut d = HashMap::new(); + for (i, &x) in inorder.iter().enumerate() { + d.insert(x, i); } - let val = preorder[0]; - let index = inorder.iter().position(|&v| v == val).unwrap(); - Some(Rc::new(RefCell::new(TreeNode { - val, - left: Self::to_tree(&preorder[1..index + 1], &inorder[..index]), - right: Self::to_tree(&preorder[index + 1..], &inorder[index + 1..]), - }))) + Self::dfs(&preorder, &d, 0, 0, preorder.len()) } - pub fn build_tree(preorder: Vec, inorder: Vec) -> Option>> { - Self::to_tree(&preorder[..], &inorder[..]) + pub fn dfs(preorder: &Vec, d: &HashMap, i: usize, j: usize, n: usize) -> Option>> { + if n <= 0 { + return None; + } + let v = preorder[i]; + let k = d[&v]; + let mut root = TreeNode::new(v); + root.left = Self::dfs(preorder, d, i + 1, j, k - j); + root.right = Self::dfs(preorder, d, i + k - j + 1, k + 1, n - k + j - 1); + Some(Rc::new(RefCell::new(root))) } } ``` @@ -283,22 +417,22 @@ impl Solution { * @return {TreeNode} */ var buildTree = function (preorder, inorder) { - function dfs(i, j, n) { + const d = new Map(); + const n = inorder.length; + for (let i = 0; i < n; ++i) { + d.set(inorder[i], i); + } + const dfs = (i, j, n) => { if (n <= 0) { return null; } const v = preorder[i]; - const k = d[v]; - const root = new TreeNode(v); - root.left = dfs(i + 1, j, k - j); - root.right = dfs(i + 1 + k - j, k + 1, n - k + j - 1); - return root; - } - const d = new Map(); - for (const [i, v] of inorder.entries()) { - d[v] = i; - } - return dfs(0, 0, inorder.length); + const k = d.get(v); + const l = dfs(i + 1, j, k - j); + const r = dfs(i + 1 + k - j, k + 1, n - 1 - (k - j)); + return new TreeNode(v, l, r); + }; + return dfs(0, 0, n); }; ``` diff --git a/solution/0100-0199/0105.Construct Binary Tree from Preorder and Inorder Traversal/Solution.cpp b/solution/0100-0199/0105.Construct Binary Tree from Preorder and Inorder Traversal/Solution.cpp index 06c02e146552a..baf5e5219c0c4 100644 --- a/solution/0100-0199/0105.Construct Binary Tree from Preorder and Inorder Traversal/Solution.cpp +++ b/solution/0100-0199/0105.Construct Binary Tree from Preorder and Inorder Traversal/Solution.cpp @@ -1,30 +1,32 @@ -/** - * Definition for a binary tree node. - * struct TreeNode { - * int val; - * TreeNode *left; - * TreeNode *right; - * TreeNode() : val(0), left(nullptr), right(nullptr) {} - * TreeNode(int x) : val(x), left(nullptr), right(nullptr) {} - * TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {} - * }; - */ -class Solution { -public: - unordered_map indexes; - - TreeNode* buildTree(vector& preorder, vector& inorder) { - for (int i = 0; i < inorder.size(); ++i) indexes[inorder[i]] = i; - return dfs(preorder, inorder, 0, 0, inorder.size()); - } - - TreeNode* dfs(vector& preorder, vector& inorder, int i, int j, int n) { - if (n <= 0) return nullptr; - int v = preorder[i]; - int k = indexes[v]; - TreeNode* root = new TreeNode(v); - root->left = dfs(preorder, inorder, i + 1, j, k - j); - root->right = dfs(preorder, inorder, i + 1 + k - j, k + 1, n - k + j - 1); - return root; - } +/** + * Definition for a binary tree node. + * struct TreeNode { + * int val; + * TreeNode *left; + * TreeNode *right; + * TreeNode() : val(0), left(nullptr), right(nullptr) {} + * TreeNode(int x) : val(x), left(nullptr), right(nullptr) {} + * TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {} + * }; + */ +class Solution { +public: + TreeNode* buildTree(vector& preorder, vector& inorder) { + int n = preorder.size(); + unordered_map d; + for (int i = 0; i < n; ++i) { + d[inorder[i]] = i; + } + function dfs = [&](int i, int j, int n) -> TreeNode* { + if (n <= 0) { + return nullptr; + } + int v = preorder[i]; + int k = d[v]; + TreeNode* l = dfs(i + 1, j, k - j); + TreeNode* r = dfs(i + 1 + k - j, k + 1, n - 1 - (k - j)); + return new TreeNode(v, l, r); + }; + return dfs(0, 0, n); + } }; \ No newline at end of file diff --git a/solution/0100-0199/0105.Construct Binary Tree from Preorder and Inorder Traversal/Solution.go b/solution/0100-0199/0105.Construct Binary Tree from Preorder and Inorder Traversal/Solution.go index dc376301b8b1b..2060cb85ac2a8 100644 --- a/solution/0100-0199/0105.Construct Binary Tree from Preorder and Inorder Traversal/Solution.go +++ b/solution/0100-0199/0105.Construct Binary Tree from Preorder and Inorder Traversal/Solution.go @@ -7,9 +7,9 @@ * } */ func buildTree(preorder []int, inorder []int) *TreeNode { - indexes := make(map[int]int) - for i, v := range inorder { - indexes[v] = i + d := map[int]int{} + for i, x := range inorder { + d[x] = i } var dfs func(i, j, n int) *TreeNode dfs = func(i, j, n int) *TreeNode { @@ -17,11 +17,10 @@ func buildTree(preorder []int, inorder []int) *TreeNode { return nil } v := preorder[i] - k := indexes[v] - root := &TreeNode{Val: v} - root.Left = dfs(i+1, j, k-j) - root.Right = dfs(i+1+k-j, k+1, n-k+j-1) - return root + k := d[v] + l := dfs(i+1, j, k-j) + r := dfs(i+1+k-j, k+1, n-1-(k-j)) + return &TreeNode{v, l, r} } - return dfs(0, 0, len(inorder)) + return dfs(0, 0, len(preorder)) } \ No newline at end of file diff --git a/solution/0100-0199/0105.Construct Binary Tree from Preorder and Inorder Traversal/Solution.java b/solution/0100-0199/0105.Construct Binary Tree from Preorder and Inorder Traversal/Solution.java index ce7ea8b974c00..55a79c30b0d13 100644 --- a/solution/0100-0199/0105.Construct Binary Tree from Preorder and Inorder Traversal/Solution.java +++ b/solution/0100-0199/0105.Construct Binary Tree from Preorder and Inorder Traversal/Solution.java @@ -1,37 +1,39 @@ -/** - * Definition for a binary tree node. - * public class TreeNode { - * int val; - * TreeNode left; - * TreeNode right; - * TreeNode() {} - * TreeNode(int val) { this.val = val; } - * TreeNode(int val, TreeNode left, TreeNode right) { - * this.val = val; - * this.left = left; - * this.right = right; - * } - * } - */ -class Solution { - private Map indexes = new HashMap<>(); - - public TreeNode buildTree(int[] preorder, int[] inorder) { - for (int i = 0; i < inorder.length; ++i) { - indexes.put(inorder[i], i); - } - return dfs(preorder, inorder, 0, 0, preorder.length); - } - - private TreeNode dfs(int[] preorder, int[] inorder, int i, int j, int n) { - if (n <= 0) { - return null; - } - int v = preorder[i]; - int k = indexes.get(v); - TreeNode root = new TreeNode(v); - root.left = dfs(preorder, inorder, i + 1, j, k - j); - root.right = dfs(preorder, inorder, i + 1 + k - j, k + 1, n - k + j - 1); - return root; - } +/** + * Definition for a binary tree node. + * public class TreeNode { + * int val; + * TreeNode left; + * TreeNode right; + * TreeNode() {} + * TreeNode(int val) { this.val = val; } + * TreeNode(int val, TreeNode left, TreeNode right) { + * this.val = val; + * this.left = left; + * this.right = right; + * } + * } + */ +class Solution { + private int[] preorder; + private Map d = new HashMap<>(); + + public TreeNode buildTree(int[] preorder, int[] inorder) { + int n = preorder.length; + this.preorder = preorder; + for (int i = 0; i < n; ++i) { + d.put(inorder[i], i); + } + return dfs(0, 0, n); + } + + private TreeNode dfs(int i, int j, int n) { + if (n <= 0) { + return null; + } + int v = preorder[i]; + int k = d.get(v); + TreeNode l = dfs(i + 1, j, k - j); + TreeNode r = dfs(i + 1 + k - j, k + 1, n - 1 - (k - j)); + return new TreeNode(v, l, r); + } } \ No newline at end of file diff --git a/solution/0100-0199/0105.Construct Binary Tree from Preorder and Inorder Traversal/Solution.js b/solution/0100-0199/0105.Construct Binary Tree from Preorder and Inorder Traversal/Solution.js index ed2e4e17fe722..fbcb291503ea8 100644 --- a/solution/0100-0199/0105.Construct Binary Tree from Preorder and Inorder Traversal/Solution.js +++ b/solution/0100-0199/0105.Construct Binary Tree from Preorder and Inorder Traversal/Solution.js @@ -12,20 +12,20 @@ * @return {TreeNode} */ var buildTree = function (preorder, inorder) { - function dfs(i, j, n) { + const d = new Map(); + const n = inorder.length; + for (let i = 0; i < n; ++i) { + d.set(inorder[i], i); + } + const dfs = (i, j, n) => { if (n <= 0) { return null; } const v = preorder[i]; - const k = d[v]; - const root = new TreeNode(v); - root.left = dfs(i + 1, j, k - j); - root.right = dfs(i + 1 + k - j, k + 1, n - k + j - 1); - return root; - } - const d = new Map(); - for (const [i, v] of inorder.entries()) { - d[v] = i; - } - return dfs(0, 0, inorder.length); + const k = d.get(v); + const l = dfs(i + 1, j, k - j); + const r = dfs(i + 1 + k - j, k + 1, n - 1 - (k - j)); + return new TreeNode(v, l, r); + }; + return dfs(0, 0, n); }; diff --git a/solution/0100-0199/0105.Construct Binary Tree from Preorder and Inorder Traversal/Solution.py b/solution/0100-0199/0105.Construct Binary Tree from Preorder and Inorder Traversal/Solution.py index 732c28b3acd0a..e0946ea996489 100644 --- a/solution/0100-0199/0105.Construct Binary Tree from Preorder and Inorder Traversal/Solution.py +++ b/solution/0100-0199/0105.Construct Binary Tree from Preorder and Inorder Traversal/Solution.py @@ -1,20 +1,19 @@ -# Definition for a binary tree node. -# class TreeNode: -# def __init__(self, val=0, left=None, right=None): -# self.val = val -# self.left = left -# self.right = right -class Solution: - def buildTree(self, preorder: List[int], inorder: List[int]) -> Optional[TreeNode]: - def dfs(i, j, n): - if n <= 0: - return None - v = preorder[i] - k = d[v] - root = TreeNode(v) - root.left = dfs(i + 1, j, k - j) - root.right = dfs(i + 1 + k - j, k + 1, n - k + j - 1) - return root - - d = {v: i for i, v in enumerate(inorder)} - return dfs(0, 0, len(preorder)) +# Definition for a binary tree node. +# class TreeNode: +# def __init__(self, val=0, left=None, right=None): +# self.val = val +# self.left = left +# self.right = right +class Solution: + def buildTree(self, preorder: List[int], inorder: List[int]) -> Optional[TreeNode]: + def dfs(i: int, j: int, n: int): + if n <= 0: + return None + v = preorder[i] + k = d[v] + l = dfs(i + 1, j, k - j) + r = dfs(i + 1 + k - j, k + 1, n - k + j - 1) + return TreeNode(v, l, r) + + d = {v: i for i, v in enumerate(inorder)} + return dfs(0, 0, len(preorder)) diff --git a/solution/0100-0199/0105.Construct Binary Tree from Preorder and Inorder Traversal/Solution.rs b/solution/0100-0199/0105.Construct Binary Tree from Preorder and Inorder Traversal/Solution.rs index 64dd66145130b..e3aa1d1b43534 100644 --- a/solution/0100-0199/0105.Construct Binary Tree from Preorder and Inorder Traversal/Solution.rs +++ b/solution/0100-0199/0105.Construct Binary Tree from Preorder and Inorder Traversal/Solution.rs @@ -1,38 +1,42 @@ -// Definition for a binary tree node. -// #[derive(Debug, PartialEq, Eq)] -// pub struct TreeNode { -// pub val: i32, -// pub left: Option>>, -// pub right: Option>>, -// } -// -// impl TreeNode { -// #[inline] -// pub fn new(val: i32) -> Self { -// TreeNode { -// val, -// left: None, -// right: None -// } -// } -// } -use std::rc::Rc; -use std::cell::RefCell; -impl Solution { - fn to_tree(preorder: &[i32], inorder: &[i32]) -> Option>> { - if preorder.is_empty() { - return None; - } - let val = preorder[0]; - let index = inorder.iter().position(|&v| v == val).unwrap(); - Some(Rc::new(RefCell::new(TreeNode { - val, - left: Self::to_tree(&preorder[1..index + 1], &inorder[..index]), - right: Self::to_tree(&preorder[index + 1..], &inorder[index + 1..]), - }))) - } - - pub fn build_tree(preorder: Vec, inorder: Vec) -> Option>> { - Self::to_tree(&preorder[..], &inorder[..]) - } -} +// Definition for a binary tree node. +// #[derive(Debug, PartialEq, Eq)] +// pub struct TreeNode { +// pub val: i32, +// pub left: Option>>, +// pub right: Option>>, +// } +// +// impl TreeNode { +// #[inline] +// pub fn new(val: i32) -> Self { +// TreeNode { +// val, +// left: None, +// right: None +// } +// } +// } +use std::rc::Rc; +use std::cell::RefCell; +use std::collections::HashMap; +impl Solution { + pub fn build_tree(preorder: Vec, inorder: Vec) -> Option>> { + let mut d = HashMap::new(); + for (i, &x) in inorder.iter().enumerate() { + d.insert(x, i); + } + Self::dfs(&preorder, &d, 0, 0, preorder.len()) + } + + pub fn dfs(preorder: &Vec, d: &HashMap, i: usize, j: usize, n: usize) -> Option>> { + if n <= 0 { + return None; + } + let v = preorder[i]; + let k = d[&v]; + let mut root = TreeNode::new(v); + root.left = Self::dfs(preorder, d, i + 1, j, k - j); + root.right = Self::dfs(preorder, d, i + k - j + 1, k + 1, n - k + j - 1); + Some(Rc::new(RefCell::new(root))) + } +} \ No newline at end of file diff --git a/solution/0100-0199/0105.Construct Binary Tree from Preorder and Inorder Traversal/Solution.ts b/solution/0100-0199/0105.Construct Binary Tree from Preorder and Inorder Traversal/Solution.ts index ceba51e7e67e3..f234477239618 100644 --- a/solution/0100-0199/0105.Construct Binary Tree from Preorder and Inorder Traversal/Solution.ts +++ b/solution/0100-0199/0105.Construct Binary Tree from Preorder and Inorder Traversal/Solution.ts @@ -13,15 +13,20 @@ */ function buildTree(preorder: number[], inorder: number[]): TreeNode | null { - const n = preorder.length; - if (n === 0) { - return null; + const d: Map = new Map(); + const n = inorder.length; + for (let i = 0; i < n; ++i) { + d.set(inorder[i], i); } - const val = preorder[0]; - const index = inorder.indexOf(val); - return new TreeNode( - val, - buildTree(preorder.slice(1, index + 1), inorder.slice(0, index)), - buildTree(preorder.slice(index + 1), inorder.slice(index + 1)), - ); + const dfs = (i: number, j: number, n: number): TreeNode | null => { + if (n <= 0) { + return null; + } + const v = preorder[i]; + const k = d.get(v)!; + const l = dfs(i + 1, j, k - j); + const r = dfs(i + 1 + k - j, k + 1, n - 1 - (k - j)); + return new TreeNode(v, l, r); + }; + return dfs(0, 0, n); } diff --git a/solution/0100-0199/0189.Rotate Array/README.md b/solution/0100-0199/0189.Rotate Array/README.md index 704410c107bd5..9132782d665e1 100644 --- a/solution/0100-0199/0189.Rotate Array/README.md +++ b/solution/0100-0199/0189.Rotate Array/README.md @@ -92,6 +92,13 @@ class Solution: reverse(k, n - 1) ``` +```python +class Solution: + def rotate(self, nums: List[int], k: int) -> None: + k %= len(nums) + nums[:] = nums[-k:] + nums[:-k] +``` + ### **Java** diff --git a/solution/0100-0199/0189.Rotate Array/README_EN.md b/solution/0100-0199/0189.Rotate Array/README_EN.md index ed2c4a7e4b64b..1fa282b69be52 100644 --- a/solution/0100-0199/0189.Rotate Array/README_EN.md +++ b/solution/0100-0199/0189.Rotate Array/README_EN.md @@ -84,6 +84,13 @@ class Solution: reverse(k, n - 1) ``` +```python +class Solution: + def rotate(self, nums: List[int], k: int) -> None: + k %= len(nums) + nums[:] = nums[-k:] + nums[:-k] +``` + ### **Java** ```java diff --git a/solution/0100-0199/0189.Rotate Array/Solution.py b/solution/0100-0199/0189.Rotate Array/Solution.py index d43f0faebd211..fe175a18c49d3 100644 --- a/solution/0100-0199/0189.Rotate Array/Solution.py +++ b/solution/0100-0199/0189.Rotate Array/Solution.py @@ -1,12 +1,4 @@ -class Solution: - def rotate(self, nums: List[int], k: int) -> None: - def reverse(i: int, j: int): - while i < j: - nums[i], nums[j] = nums[j], nums[i] - i, j = i + 1, j - 1 - - n = len(nums) - k %= n - reverse(0, n - 1) - reverse(0, k - 1) - reverse(k, n - 1) +class Solution: + def rotate(self, nums: List[int], k: int) -> None: + k %= len(nums) + nums[:] = nums[-k:] + nums[:-k]