Skip to content

Commit caa9330

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

File tree

6 files changed

+257
-130
lines changed

6 files changed

+257
-130
lines changed

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

+87-43
Original file line numberDiff line numberDiff line change
@@ -40,27 +40,20 @@
4040
```python
4141
# Definition for a binary tree node.
4242
# class TreeNode:
43-
# def __init__(self, x):
44-
# self.val = x
45-
# self.left = None
46-
# self.right = None
47-
43+
# def __init__(self, val=0, left=None, right=None):
44+
# self.val = val
45+
# self.left = left
46+
# self.right = right
4847
class Solution:
49-
indexes = {}
5048
def buildTree(self, inorder: List[int], postorder: List[int]) -> TreeNode:
51-
def build(inorder, postorder, i1, i2, p1, p2):
52-
if i1 > i2 or p1 > p2:
53-
return None
54-
root_val = postorder[p2]
55-
pos = self.indexes[root_val]
56-
root = TreeNode(root_val)
57-
root.left = None if pos == i1 else build(inorder, postorder, i1, pos - 1, p1, p1 - i1 + pos - 1)
58-
root.right = None if pos == i2 else build(inorder, postorder, pos + 1, i2, p1 - i1 + pos, p2 - 1)
59-
return root
60-
n = len(inorder)
61-
for i in range(n):
62-
self.indexes[inorder[i]] = i
63-
return build(inorder, postorder, 0, n - 1, 0, n - 1)
49+
if not postorder:
50+
return None
51+
v = postorder[-1]
52+
root = TreeNode(val=v)
53+
i = inorder.index(v)
54+
root.left = self.buildTree(inorder[: i], postorder[:i])
55+
root.right = self.buildTree(inorder[i + 1:], postorder[i:-1])
56+
return root
6457
```
6558

6659
### **Java**
@@ -74,27 +67,34 @@ class Solution:
7467
* int val;
7568
* TreeNode left;
7669
* TreeNode right;
77-
* TreeNode(int x) { val = x; }
70+
* TreeNode() {}
71+
* TreeNode(int val) { this.val = val; }
72+
* TreeNode(int val, TreeNode left, TreeNode right) {
73+
* this.val = val;
74+
* this.left = left;
75+
* this.right = right;
76+
* }
7877
* }
7978
*/
8079
class Solution {
8180
private Map<Integer, Integer> indexes = new HashMap<>();
8281

8382
public TreeNode buildTree(int[] inorder, int[] postorder) {
84-
int n = inorder.length;
85-
for (int i = 0; i < n; ++i) {
83+
for (int i = 0; i < inorder.length; ++i) {
8684
indexes.put(inorder[i], i);
8785
}
88-
return build(inorder, postorder, 0, inorder.length - 1, 0, postorder.length - 1);
86+
return dfs(inorder, postorder, 0, 0, inorder.length);
8987
}
9088

91-
private TreeNode build(int[] inorder, int[] postorder, int i1, int i2, int p1, int p2) {
92-
if (i1 > i2 || p1 > p2) return null;
93-
int rootVal = postorder[p2];
94-
int pos = indexes.get(rootVal);
95-
TreeNode root = new TreeNode(rootVal);
96-
root.left = pos == i1 ? null : build(inorder, postorder, i1, pos - 1, p1, p1 - i1 + pos - 1);
97-
root.right = pos == i2 ? null : build(inorder, postorder, pos + 1, i2, p1 - i1 + pos, p2 - 1);
89+
private TreeNode dfs(int[] inorder, int[] postorder, int i, int j, int n) {
90+
if (n <= 0) {
91+
return null;
92+
}
93+
int v = postorder[j + n - 1];
94+
int k = indexes.get(v);
95+
TreeNode root = new TreeNode(v);
96+
root.left = dfs(inorder, postorder, i, j, k - i);
97+
root.right = dfs(inorder, postorder, k + 1, j + k - i, n - k + i - 1);
9898
return root;
9999
}
100100
}
@@ -103,26 +103,70 @@ class Solution {
103103
### **C++**
104104

105105
```cpp
106+
/**
107+
* Definition for a binary tree node.
108+
* struct TreeNode {
109+
* int val;
110+
* TreeNode *left;
111+
* TreeNode *right;
112+
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
113+
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
114+
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
115+
* };
116+
*/
106117
class Solution {
107118
public:
108-
TreeNode *buildTree(vector<int> &inorder, vector<int> &postorder) {
109-
return buildTree(inorder, 0, inorder.size() - 1, postorder, 0, postorder.size() - 1);
119+
unordered_map<int, int> indexes;
120+
121+
TreeNode* buildTree(vector<int>& inorder, vector<int>& postorder) {
122+
for (int i = 0; i < inorder.size(); ++i) indexes[inorder[i]] = i;
123+
return dfs(inorder, postorder, 0, 0, inorder.size());
110124
}
111-
TreeNode *buildTree(vector<int> &inorder, int iLeft, int iRight, vector<int> &postorder, int pLeft, int pRight) {
112-
if (iLeft > iRight || pLeft > pRight) return NULL;
113-
TreeNode *cur = new TreeNode(postorder[pRight]);
114-
int i = 0;
115-
for (i = iLeft; i < inorder.size(); ++i) {
116-
if (inorder[i] == cur->val)
117-
break;
118-
}
119-
cur->left = buildTree(inorder, iLeft, i - 1, postorder, pLeft, pLeft + i - iLeft - 1);
120-
cur->right = buildTree(inorder, i + 1, iRight, postorder, pLeft + i - iLeft, pRight - 1);
121-
return cur;
125+
126+
TreeNode* dfs(vector<int>& inorder, vector<int>& postorder, int i, int j, int n) {
127+
if (n <= 0) return nullptr;
128+
int v = postorder[j + n - 1];
129+
int k = indexes[v];
130+
TreeNode* root = new TreeNode(v);
131+
root->left = dfs(inorder, postorder, i, j, k - i);
132+
root->right = dfs(inorder, postorder, k + 1, j + k - i, n - k + i - 1);
133+
return root;
122134
}
123135
};
124136
```
125137
138+
### **Go**
139+
140+
```go
141+
/**
142+
* Definition for a binary tree node.
143+
* type TreeNode struct {
144+
* Val int
145+
* Left *TreeNode
146+
* Right *TreeNode
147+
* }
148+
*/
149+
func buildTree(inorder []int, postorder []int) *TreeNode {
150+
indexes := make(map[int]int)
151+
for i, v := range inorder {
152+
indexes[v] = i
153+
}
154+
var dfs func(i, j, n int) *TreeNode
155+
dfs = func(i, j, n int) *TreeNode {
156+
if n <= 0 {
157+
return nil
158+
}
159+
v := postorder[j+n-1]
160+
k := indexes[v]
161+
root := &TreeNode{Val: v}
162+
root.Left = dfs(i, j, k-i)
163+
root.Right = dfs(k+1, j+k-i, n-k+i-1)
164+
return root
165+
}
166+
return dfs(0, 0, len(inorder))
167+
}
168+
```
169+
126170
### **...**
127171

128172
```

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

+87-43
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, inorder: List[int], postorder: List[int]) -> TreeNode:
54-
def build(inorder, postorder, i1, i2, p1, p2):
55-
if i1 > i2 or p1 > p2:
56-
return None
57-
root_val = postorder[p2]
58-
pos = self.indexes[root_val]
59-
root = TreeNode(root_val)
60-
root.left = None if pos == i1 else build(inorder, postorder, i1, pos - 1, p1, p1 - i1 + pos - 1)
61-
root.right = None if pos == i2 else build(inorder, postorder, pos + 1, i2, p1 - i1 + pos, p2 - 1)
62-
return root
63-
n = len(inorder)
64-
for i in range(n):
65-
self.indexes[inorder[i]] = i
66-
return build(inorder, postorder, 0, n - 1, 0, n - 1)
52+
if not postorder:
53+
return None
54+
v = postorder[-1]
55+
root = TreeNode(val=v)
56+
i = inorder.index(v)
57+
root.left = self.buildTree(inorder[: i], postorder[:i])
58+
root.right = self.buildTree(inorder[i + 1:], postorder[i:-1])
59+
return root
6760
```
6861

6962
### **Java**
@@ -75,27 +68,34 @@ 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[] inorder, int[] postorder) {
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(inorder, postorder, 0, inorder.length - 1, 0, postorder.length - 1);
87+
return dfs(inorder, postorder, 0, 0, inorder.length);
9088
}
9189

92-
private TreeNode build(int[] inorder, int[] postorder, int i1, int i2, int p1, int p2) {
93-
if (i1 > i2 || p1 > p2) return null;
94-
int rootVal = postorder[p2];
95-
int pos = indexes.get(rootVal);
96-
TreeNode root = new TreeNode(rootVal);
97-
root.left = pos == i1 ? null : build(inorder, postorder, i1, pos - 1, p1, p1 - i1 + pos - 1);
98-
root.right = pos == i2 ? null : build(inorder, postorder, pos + 1, i2, p1 - i1 + pos, p2 - 1);
90+
private TreeNode dfs(int[] inorder, int[] postorder, int i, int j, int n) {
91+
if (n <= 0) {
92+
return null;
93+
}
94+
int v = postorder[j + n - 1];
95+
int k = indexes.get(v);
96+
TreeNode root = new TreeNode(v);
97+
root.left = dfs(inorder, postorder, i, j, k - i);
98+
root.right = dfs(inorder, postorder, k + 1, j + k - i, n - k + i - 1);
9999
return root;
100100
}
101101
}
@@ -104,26 +104,70 @@ class Solution {
104104
### **C++**
105105

106106
```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+
*/
107118
class Solution {
108119
public:
109-
TreeNode *buildTree(vector<int> &inorder, vector<int> &postorder) {
110-
return buildTree(inorder, 0, inorder.size() - 1, postorder, 0, postorder.size() - 1);
120+
unordered_map<int, int> indexes;
121+
122+
TreeNode* buildTree(vector<int>& inorder, vector<int>& postorder) {
123+
for (int i = 0; i < inorder.size(); ++i) indexes[inorder[i]] = i;
124+
return dfs(inorder, postorder, 0, 0, inorder.size());
111125
}
112-
TreeNode *buildTree(vector<int> &inorder, int iLeft, int iRight, vector<int> &postorder, int pLeft, int pRight) {
113-
if (iLeft > iRight || pLeft > pRight) return NULL;
114-
TreeNode *cur = new TreeNode(postorder[pRight]);
115-
int i = 0;
116-
for (i = iLeft; i < inorder.size(); ++i) {
117-
if (inorder[i] == cur->val)
118-
break;
119-
}
120-
cur->left = buildTree(inorder, iLeft, i - 1, postorder, pLeft, pLeft + i - iLeft - 1);
121-
cur->right = buildTree(inorder, i + 1, iRight, postorder, pLeft + i - iLeft, pRight - 1);
122-
return cur;
126+
127+
TreeNode* dfs(vector<int>& inorder, vector<int>& postorder, int i, int j, int n) {
128+
if (n <= 0) return nullptr;
129+
int v = postorder[j + n - 1];
130+
int k = indexes[v];
131+
TreeNode* root = new TreeNode(v);
132+
root->left = dfs(inorder, postorder, i, j, k - i);
133+
root->right = dfs(inorder, postorder, k + 1, j + k - i, n - k + i - 1);
134+
return root;
123135
}
124136
};
125137
```
126138
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(inorder []int, postorder []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 := postorder[j+n-1]
161+
k := indexes[v]
162+
root := &TreeNode{Val: v}
163+
root.Left = dfs(i, j, k-i)
164+
root.Right = dfs(k+1, j+k-i, n-k+i-1)
165+
return root
166+
}
167+
return dfs(0, 0, len(inorder))
168+
}
169+
```
170+
127171
### **...**
128172

129173
```

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

+25-13
Original file line numberDiff line numberDiff line change
@@ -1,18 +1,30 @@
1+
/**
2+
* Definition for a binary tree node.
3+
* struct TreeNode {
4+
* int val;
5+
* TreeNode *left;
6+
* TreeNode *right;
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) {}
10+
* };
11+
*/
112
class Solution {
213
public:
3-
TreeNode *buildTree(vector<int> &inorder, vector<int> &postorder) {
4-
return buildTree(inorder, 0, inorder.size() - 1, postorder, 0, postorder.size() - 1);
14+
unordered_map<int, int> indexes;
15+
16+
TreeNode* buildTree(vector<int>& inorder, vector<int>& postorder) {
17+
for (int i = 0; i < inorder.size(); ++i) indexes[inorder[i]] = i;
18+
return dfs(inorder, postorder, 0, 0, inorder.size());
519
}
6-
TreeNode *buildTree(vector<int> &inorder, int iLeft, int iRight, vector<int> &postorder, int pLeft, int pRight) {
7-
if (iLeft > iRight || pLeft > pRight) return NULL;
8-
TreeNode *cur = new TreeNode(postorder[pRight]);
9-
int i = 0;
10-
for (i = iLeft; i < inorder.size(); ++i) {
11-
if (inorder[i] == cur->val)
12-
break;
13-
}
14-
cur->left = buildTree(inorder, iLeft, i - 1, postorder, pLeft, pLeft + i - iLeft - 1);
15-
cur->right = buildTree(inorder, i + 1, iRight, postorder, pLeft + i - iLeft, pRight - 1);
16-
return cur;
20+
21+
TreeNode* dfs(vector<int>& inorder, vector<int>& postorder, int i, int j, int n) {
22+
if (n <= 0) return nullptr;
23+
int v = postorder[j + n - 1];
24+
int k = indexes[v];
25+
TreeNode* root = new TreeNode(v);
26+
root->left = dfs(inorder, postorder, i, j, k - i);
27+
root->right = dfs(inorder, postorder, k + 1, j + k - i, n - k + i - 1);
28+
return root;
1729
}
1830
};

0 commit comments

Comments
 (0)