Skip to content

Commit 2c05a5f

Browse files
yanglbmeyanglbme
committed
feat: add solutions to lc problem: No.0105
No.0105.Construct Binary Tree from Preorder and Inorder Traversal
1 parent 1c464ee commit 2c05a5f

File tree

6 files changed

+270
-113
lines changed

6 files changed

+270
-113
lines changed

‎solution/0100-0199/0105.Construct Binary Tree from Preorder and Inorder Traversal/README.md

+98-35
Original file line numberDiff line numberDiff line change
@@ -45,29 +45,20 @@
4545
```python
4646
# Definition for a binary tree node.
4747
# class TreeNode:
48-
# def __init__(self, x):
49-
# self.val = x
50-
# self.left = None
51-
# self.right = None
52-
48+
# def __init__(self, val=0, left=None, right=None):
49+
# self.val = val
50+
# self.left = left
51+
# self.right = right
5352
class Solution:
54-
indexes = {}
5553
def buildTree(self, preorder: List[int], inorder: List[int]) -> TreeNode:
56-
def build(preorder, inorder, p1, p2, i1, i2) -> TreeNode:
57-
if p1 > p2 or i1 > i2:
58-
return None
59-
root_val = preorder[p1]
60-
pos = self.indexes[root_val]
61-
root = TreeNode(root_val)
62-
# pos==i1，说明只有右子树，左子树为空
63-
root.left = None if pos == i1 else build(preorder, inorder, p1 + 1, p1 - i1 + pos, i1, pos - 1)
64-
# pos==i2，说明只有左子树，右子树为空
65-
root.right = None if pos == i2 else build(preorder, inorder, p1 - i1 + pos + 1, p2, pos + 1, i2)
66-
return root
67-
n = len(inorder)
68-
for i in range(n):
69-
self.indexes[inorder[i]] = i
70-
return build(preorder, inorder, 0, n - 1, 0, n - 1)
54+
if not preorder:
55+
return None
56+
v = preorder[0]
57+
root = TreeNode(val=v)
58+
i = inorder.index(v)
59+
root.left = self.buildTree(preorder[1:1 + i], inorder[:i])
60+
root.right = self.buildTree(preorder[1 + i:], inorder[i + 1:])
61+
return root
7162
```
7263

7364
### **Java**
@@ -81,31 +72,103 @@ class Solution:
8172
* int val;
8273
* TreeNode left;
8374
* TreeNode right;
84-
* TreeNode(int x) { val = x; }
75+
* TreeNode() {}
76+
* TreeNode(int val) { this.val = val; }
77+
* TreeNode(int val, TreeNode left, TreeNode right) {
78+
* this.val = val;
79+
* this.left = left;
80+
* this.right = right;
81+
* }
8582
* }
8683
*/
8784
class Solution {
8885
private Map<Integer, Integer> indexes = new HashMap<>();
8986

9087
public TreeNode buildTree(int[] preorder, int[] inorder) {
91-
int n = inorder.length;
92-
for (int i = 0; i < n; ++i) {
88+
for (int i = 0; i < inorder.length; ++i) {
9389
indexes.put(inorder[i], i);
9490
}
95-
return build(preorder, inorder, 0, n - 1, 0, n - 1);
91+
return dfs(preorder, inorder, 0, 0, preorder.length);
92+
}
93+
94+
private TreeNode dfs(int[] preorder, int[] inorder, int i, int j, int n) {
95+
if (n <= 0) {
96+
return null;
97+
}
98+
int v = preorder[i];
99+
int k = indexes.get(v);
100+
TreeNode root = new TreeNode(v);
101+
root.left = dfs(preorder, inorder, i + 1, j, k - j);
102+
root.right = dfs(preorder, inorder, i + 1 + k - j, k + 1, n - k + j - 1);
103+
return root;
104+
}
105+
}
106+
```
107+
108+
### **C++**
109+
110+
```cpp
111+
/**
112+
* Definition for a binary tree node.
113+
* struct TreeNode {
114+
* int val;
115+
* TreeNode *left;
116+
* TreeNode *right;
117+
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
118+
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
119+
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
120+
* };
121+
*/
122+
class Solution {
123+
public:
124+
unordered_map<int, int> indexes;
125+
126+
TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
127+
for (int i = 0; i < inorder.size(); ++i) indexes[inorder[i]] = i;
128+
return dfs(preorder, inorder, 0, 0, inorder.size());
96129
}
97130

98-
private TreeNode build(int[] preorder, int[] inorder, int p1, int p2, int i1, int i2) {
99-
if (p1 > p2 || i1 > i2) return null;
100-
int rootVal = preorder[p1];
101-
int pos = indexes.get(rootVal);
102-
TreeNode node = new TreeNode(rootVal);
103-
// pos==i1，说明只有右子树，左子树为空
104-
node.left = pos == i1 ? null : build(preorder, inorder, p1 + 1, pos - i1 + p1, i1, pos - 1);
105-
// pos==i2，说明只有左子树，右子树为空
106-
node.right = pos == i2 ? null : build(preorder, inorder, pos - i1 + p1 + 1, p2, pos + 1, i2);
107-
return node;
131+
TreeNode* dfs(vector<int>& preorder, vector<int>& inorder, int i, int j, int n) {
132+
if (n <= 0) return nullptr;
133+
int v = preorder[i];
134+
int k = indexes[v];
135+
TreeNode* root = new TreeNode(v);
136+
root->left = dfs(preorder, inorder, i + 1, j, k - j);
137+
root->right = dfs(preorder, inorder, i + 1 + k - j, k + 1, n - k + j - 1);
138+
return root;
108139
}
140+
};
141+
```
142+
143+
### **Go**
144+
145+
```go
146+
/**
147+
* Definition for a binary tree node.
148+
* type TreeNode struct {
149+
* Val int
150+
* Left *TreeNode
151+
* Right *TreeNode
152+
* }
153+
*/
154+
func buildTree(preorder []int, inorder []int) *TreeNode {
155+
indexes := make(map[int]int)
156+
for i, v := range inorder {
157+
indexes[v] = i
158+
}
159+
var dfs func(i, j, n int) *TreeNode
160+
dfs = func(i, j, n int) *TreeNode {
161+
if n <= 0 {
162+
return nil
163+
}
164+
v := preorder[i]
165+
k := indexes[v]
166+
root := &TreeNode{Val: v}
167+
root.Left = dfs(i+1, j, k-j)
168+
root.Right = dfs(i+1+k-j, k+1, n-k+j-1)
169+
return root
170+
}
171+
return dfs(0, 0, len(inorder))
109172
}
110173
```
111174

‎solution/0100-0199/0105.Construct Binary Tree from Preorder and Inorder Traversal/README_EN.md

+98-31
Original file line numberDiff line numberDiff line change
@@ -43,27 +43,20 @@
4343
```python
4444
# Definition for a binary tree node.
4545
# class TreeNode:
46-
# def __init__(self, x):
47-
# self.val = x
48-
# self.left = None
49-
# self.right = None
50-
46+
# def __init__(self, val=0, left=None, right=None):
47+
# self.val = val
48+
# self.left = left
49+
# self.right = right
5150
class Solution:
52-
indexes = {}
5351
def buildTree(self, preorder: List[int], inorder: List[int]) -> TreeNode:
54-
def build(preorder, inorder, p1, p2, i1, i2) -> TreeNode:
55-
if p1 > p2 or i1 > i2:
56-
return None
57-
root_val = preorder[p1]
58-
pos = self.indexes[root_val]
59-
root = TreeNode(root_val)
60-
root.left = None if pos == i1 else build(preorder, inorder, p1 + 1, p1 - i1 + pos, i1, pos - 1)
61-
root.right = None if pos == i2 else build(preorder, inorder, p1 - i1 + pos + 1, p2, pos + 1, i2)
62-
return root
63-
n = len(inorder)
64-
for i in range(n):
65-
self.indexes[inorder[i]] = i
66-
return build(preorder, inorder, 0, n - 1, 0, n - 1)
52+
if not preorder:
53+
return None
54+
v = preorder[0]
55+
root = TreeNode(val=v)
56+
i = inorder.index(v)
57+
root.left = self.buildTree(preorder[1:1 + i], inorder[:i])
58+
root.right = self.buildTree(preorder[1 + i:], inorder[i + 1:])
59+
return root
6760
```
6861

6962
### **Java**
@@ -75,29 +68,103 @@ class Solution:
7568
* int val;
7669
* TreeNode left;
7770
* TreeNode right;
78-
* TreeNode(int x) { val = x; }
71+
* TreeNode() {}
72+
* TreeNode(int val) { this.val = val; }
73+
* TreeNode(int val, TreeNode left, TreeNode right) {
74+
* this.val = val;
75+
* this.left = left;
76+
* this.right = right;
77+
* }
7978
* }
8079
*/
8180
class Solution {
8281
private Map<Integer, Integer> indexes = new HashMap<>();
8382

8483
public TreeNode buildTree(int[] preorder, int[] inorder) {
85-
int n = inorder.length;
86-
for (int i = 0; i < n; ++i) {
84+
for (int i = 0; i < inorder.length; ++i) {
8785
indexes.put(inorder[i], i);
8886
}
89-
return build(preorder, inorder, 0, n - 1, 0, n - 1);
87+
return dfs(preorder, inorder, 0, 0, preorder.length);
88+
}
89+
90+
private TreeNode dfs(int[] preorder, int[] inorder, int i, int j, int n) {
91+
if (n <= 0) {
92+
return null;
93+
}
94+
int v = preorder[i];
95+
int k = indexes.get(v);
96+
TreeNode root = new TreeNode(v);
97+
root.left = dfs(preorder, inorder, i + 1, j, k - j);
98+
root.right = dfs(preorder, inorder, i + 1 + k - j, k + 1, n - k + j - 1);
99+
return root;
100+
}
101+
}
102+
```
103+
104+
### **C++**
105+
106+
```cpp
107+
/**
108+
* Definition for a binary tree node.
109+
* struct TreeNode {
110+
* int val;
111+
* TreeNode *left;
112+
* TreeNode *right;
113+
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
114+
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
115+
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
116+
* };
117+
*/
118+
class Solution {
119+
public:
120+
unordered_map<int, int> indexes;
121+
122+
TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
123+
for (int i = 0; i < inorder.size(); ++i) indexes[inorder[i]] = i;
124+
return dfs(preorder, inorder, 0, 0, inorder.size());
90125
}
91126

92-
private TreeNode build(int[] preorder, int[] inorder, int p1, int p2, int i1, int i2) {
93-
if (p1 > p2 || i1 > i2) return null;
94-
int rootVal = preorder[p1];
95-
int pos = indexes.get(rootVal);
96-
TreeNode node = new TreeNode(rootVal);
97-
node.left = pos == i1 ? null : build(preorder, inorder, p1 + 1, pos - i1 + p1, i1, pos - 1);
98-
node.right = pos == i2 ? null : build(preorder, inorder, pos - i1 + p1 + 1, p2, pos + 1, i2);
99-
return node;
127+
TreeNode* dfs(vector<int>& preorder, vector<int>& inorder, int i, int j, int n) {
128+
if (n <= 0) return nullptr;
129+
int v = preorder[i];
130+
int k = indexes[v];
131+
TreeNode* root = new TreeNode(v);
132+
root->left = dfs(preorder, inorder, i + 1, j, k - j);
133+
root->right = dfs(preorder, inorder, i + 1 + k - j, k + 1, n - k + j - 1);
134+
return root;
100135
}
136+
};
137+
```
138+
139+
### **Go**
140+
141+
```go
142+
/**
143+
* Definition for a binary tree node.
144+
* type TreeNode struct {
145+
* Val int
146+
* Left *TreeNode
147+
* Right *TreeNode
148+
* }
149+
*/
150+
func buildTree(preorder []int, inorder []int) *TreeNode {
151+
indexes := make(map[int]int)
152+
for i, v := range inorder {
153+
indexes[v] = i
154+
}
155+
var dfs func(i, j, n int) *TreeNode
156+
dfs = func(i, j, n int) *TreeNode {
157+
if n <= 0 {
158+
return nil
159+
}
160+
v := preorder[i]
161+
k := indexes[v]
162+
root := &TreeNode{Val: v}
163+
root.Left = dfs(i+1, j, k-j)
164+
root.Right = dfs(i+1+k-j, k+1, n-k+j-1)
165+
return root
166+
}
167+
return dfs(0, 0, len(inorder))
101168
}
102169
```
103170

‎solution/0100-0199/0105.Construct Binary Tree from Preorder and Inorder Traversal/Solution.cpp

+16-16
Original file line numberDiff line numberDiff line change
@@ -4,27 +4,27 @@
44
* int val;
55
* TreeNode *left;
66
* TreeNode *right;
7-
* TreeNode(int x) : val(x), left(NULL), right(NULL) {}
7+
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
8+
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
9+
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
810
* };
911
*/
1012
class Solution {
1113
public:
14+
unordered_map<int, int> indexes;
15+
1216
TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
13-
int pRight = preorder.size()-1;
14-
int iRight = inorder.size()-1;
15-
return build(preorder,inorder,0,pRight,0,iRight);
17+
for (int i = 0; i < inorder.size(); ++i) indexes[inorder[i]] = i;
18+
return dfs(preorder, inorder, 0, 0, inorder.size());
1619
}
17-
18-
19-
TreeNode* build(vector<int>& preorder,vector<int>& inorder,int pLeft,int pRight,int iLeft,int iRight){
20-
if(pLeft > pRight)return NULL;
21-
22-
TreeNode *node = new TreeNode(preorder[pLeft]);
23-
int idx = iLeft;
24-
25-
while(inorder[idx] != preorder[pLeft])idx++;
26-
node->left = build(preorder,inorder,pLeft+1,pLeft+idx-iLeft,iLeft,idx-1);
27-
node->right = build(preorder,inorder,pLeft+idx-iLeft+1,pRight,idx+1,iRight);
28-
return node;
20+
21+
TreeNode* dfs(vector<int>& preorder, vector<int>& inorder, int i, int j, int n) {
22+
if (n <= 0) return nullptr;
23+
int v = preorder[i];
24+
int k = indexes[v];
25+
TreeNode* root = new TreeNode(v);
26+
root->left = dfs(preorder, inorder, i + 1, j, k - j);
27+
root->right = dfs(preorder, inorder, i + 1 + k - j, k + 1, n - k + j - 1);
28+
return root;
2929
}
3030
};

‎solution/0100-0199/0105.Construct Binary Tree from Preorder and Inorder Traversal/Solution.go

+27
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,27 @@
1+
/**
2+
* Definition for a binary tree node.
3+
* type TreeNode struct {
4+
* Val int
5+
* Left *TreeNode
6+
* Right *TreeNode
7+
* }
8+
*/
9+
func buildTree(preorder []int, inorder []int) *TreeNode {
10+
indexes := make(map[int]int)
11+
for i, v := range inorder {
12+
indexes[v] = i
13+
}
14+
var dfs func(i, j, n int) *TreeNode
15+
dfs = func(i, j, n int) *TreeNode {
16+
if n <= 0 {
17+
return nil
18+
}
19+
v := preorder[i]
20+
k := indexes[v]
21+
root := &TreeNode{Val: v}
22+
root.Left = dfs(i+1, j, k-j)
23+
root.Right = dfs(i+1+k-j, k+1, n-k+j-1)
24+
return root
25+
}
26+
return dfs(0, 0, len(inorder))
27+
}

0 commit comments

Comments
 (0)