Skip to content

feat: add solutions to lc problem: No.0105 #1423

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
merged 1 commit into from
Aug 9, 2023
Merged

feat: add solutions to lc problem: No.0105 #1423

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
316 changes: 226 additions & 90 deletions ...0-0199/0105.Construct Binary Tree from Preorder and Inorder Traversal/README.md
View file
Open in desktop

Large diffs are not rendered by default.

312 changes: 223 additions & 89 deletions ...199/0105.Construct Binary Tree from Preorder and Inorder Traversal/README_EN.md
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -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
Expand All @@ -101,25 +102,71 @@ class Solution:
* }
*/
class Solution {
private Map<Integer, Integer> indexes = new HashMap<>();
private int[] preorder;
private int[] inorder;
private Map<Integer, Integer> 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<Integer, Integer> 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);
}
}
```
Expand All @@ -140,21 +187,68 @@ class Solution {
*/
class Solution {
public:
unordered_map<int, int> indexes;

TreeNode* buildTree(vector<int>& preorder, vector<int>& 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<int, int> d;
for (int i = 0; i < n; ++i) {
d[inorder[i]] = i;
}
function<TreeNode*(int, int, int)> 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<int>& preorder, vector<int>& 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<TreeNode*> getBinaryTrees(vector<int>& preOrder, vector<int>& inOrder) {
int n = inOrder.size();
unordered_map<int, vector<int>> d;
for (int i = 0; i < n; ++i) {
d[inOrder[i]].push_back(i);
}
function<vector<TreeNode*>(int, int, int)> dfs = [&](int i,int j, int n) -> vector<TreeNode*> {
vector<TreeNode*> 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);
}
};
```
Expand All @@ -171,23 +265,54 @@ 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 {
if n <= 0 {
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)
}
```

Expand All @@ -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<number, number> = 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);
}
```

Expand All @@ -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<Rc<RefCell<TreeNode>>> {
if preorder.is_empty() {
return None;
pub fn build_tree(preorder: Vec<i32>, inorder: Vec<i32>) -> Option<Rc<RefCell<TreeNode>>> {
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<i32>, inorder: Vec<i32>) -> Option<Rc<RefCell<TreeNode>>> {
Self::to_tree(&preorder[..], &inorder[..])
pub fn dfs(preorder: &Vec<i32>, d: &HashMap<i32, usize>, i: usize, j: usize, n: usize) -> Option<Rc<RefCell<TreeNode>>> {
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)))
}
}
```
Expand All @@ -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);
};
```

Expand Down
Loading