Skip to content

Commit 29f49eb

Browse files
yanglbmeyanglbme
committed
feat: add solutions to lcci problem: No.04.06
No.04.06.Successor
1 parent e20ec94 commit 29f49eb

File tree

6 files changed

+348
-2
lines changed

6 files changed

+348
-2
lines changed

‎lcci/04.06.Successor/README.md‎

Lines changed: 119 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -44,15 +44,133 @@
4444
<!-- 这里可写当前语言的特殊实现逻辑 -->
4545

4646
```python
47-
47+
# Definition for a binary tree node.
48+
# class TreeNode:
49+
# def __init__(self, x):
50+
# self.val = x
51+
# self.left = None
52+
# self.right = None
53+
54+
class Solution:
55+
def inorderSuccessor(self, root: TreeNode, p: TreeNode) -> TreeNode:
56+
def dfs(root):
57+
if root is None:
58+
return
59+
dfs(root.left)
60+
nonlocal ans, prev
61+
if prev == p:
62+
ans = root
63+
prev = root
64+
dfs(root.right)
65+
66+
ans = prev = None
67+
dfs(root)
68+
return ans
4869
```
4970

5071
### **Java**
5172

5273
<!-- 这里可写当前语言的特殊实现逻辑 -->
5374

5475
```java
76+
/**
77+
* Definition for a binary tree node.
78+
* public class TreeNode {
79+
* int val;
80+
* TreeNode left;
81+
* TreeNode right;
82+
* TreeNode(int x) { val = x; }
83+
* }
84+
*/
85+
class Solution {
86+
private TreeNode prev;
87+
private TreeNode p;
88+
private TreeNode ans;
89+
90+
public TreeNode inorderSuccessor(TreeNode root, TreeNode p) {
91+
prev = null;
92+
ans = null;
93+
this.p = p;
94+
dfs(root);
95+
return ans;
96+
}
97+
98+
private void dfs(TreeNode root) {
99+
if (root == null) {
100+
return;
101+
}
102+
dfs(root.left);
103+
if (prev == p) {
104+
ans = root;
105+
}
106+
prev = root;
107+
dfs(root.right);
108+
}
109+
}
110+
```
111+
112+
### **C++**
113+
114+
```cpp
115+
/**
116+
* Definition for a binary tree node.
117+
* struct TreeNode {
118+
* int val;
119+
* TreeNode *left;
120+
* TreeNode *right;
121+
* TreeNode(int x) : val(x), left(NULL), right(NULL) {}
122+
* };
123+
*/
124+
class Solution {
125+
public:
126+
TreeNode* prev;
127+
TreeNode* p;
128+
TreeNode* ans;
129+
130+
TreeNode* inorderSuccessor(TreeNode* root, TreeNode* p) {
131+
this->p = p;
132+
dfs(root);
133+
return ans;
134+
}
135+
136+
void dfs(TreeNode* root) {
137+
if (!root) return;
138+
dfs(root->left);
139+
if (prev == p) ans = root;
140+
prev = root;
141+
dfs(root->right);
142+
}
143+
};
144+
```
55145
146+
### **Go**
147+
148+
```go
149+
/**
150+
* Definition for a binary tree node.
151+
* type TreeNode struct {
152+
* Val int
153+
* Left *TreeNode
154+
* Right *TreeNode
155+
* }
156+
*/
157+
func inorderSuccessor(root *TreeNode, p *TreeNode) *TreeNode {
158+
var prev, ans *TreeNode
159+
var dfs func(root *TreeNode)
160+
dfs = func(root *TreeNode) {
161+
if root == nil {
162+
return
163+
}
164+
dfs(root.Left)
165+
if prev == p {
166+
ans = root
167+
}
168+
prev = root
169+
dfs(root.Right)
170+
}
171+
dfs(root)
172+
return ans
173+
}
56174
```
57175

58176
### **...**

‎lcci/04.06.Successor/README_EN.md‎

Lines changed: 119 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -59,13 +59,131 @@
5959
### **Python3**
6060

6161
```python
62-
62+
# Definition for a binary tree node.
63+
# class TreeNode:
64+
# def __init__(self, x):
65+
# self.val = x
66+
# self.left = None
67+
# self.right = None
68+
69+
class Solution:
70+
def inorderSuccessor(self, root: TreeNode, p: TreeNode) -> TreeNode:
71+
def dfs(root):
72+
if root is None:
73+
return
74+
dfs(root.left)
75+
nonlocal ans, prev
76+
if prev == p:
77+
ans = root
78+
prev = root
79+
dfs(root.right)
80+
81+
ans = prev = None
82+
dfs(root)
83+
return ans
6384
```
6485

6586
### **Java**
6687

6788
```java
89+
/**
90+
* Definition for a binary tree node.
91+
* public class TreeNode {
92+
* int val;
93+
* TreeNode left;
94+
* TreeNode right;
95+
* TreeNode(int x) { val = x; }
96+
* }
97+
*/
98+
class Solution {
99+
private TreeNode prev;
100+
private TreeNode p;
101+
private TreeNode ans;
102+
103+
public TreeNode inorderSuccessor(TreeNode root, TreeNode p) {
104+
prev = null;
105+
ans = null;
106+
this.p = p;
107+
dfs(root);
108+
return ans;
109+
}
110+
111+
private void dfs(TreeNode root) {
112+
if (root == null) {
113+
return;
114+
}
115+
dfs(root.left);
116+
if (prev == p) {
117+
ans = root;
118+
}
119+
prev = root;
120+
dfs(root.right);
121+
}
122+
}
123+
```
124+
125+
### **C++**
126+
127+
```cpp
128+
/**
129+
* Definition for a binary tree node.
130+
* struct TreeNode {
131+
* int val;
132+
* TreeNode *left;
133+
* TreeNode *right;
134+
* TreeNode(int x) : val(x), left(NULL), right(NULL) {}
135+
* };
136+
*/
137+
class Solution {
138+
public:
139+
TreeNode* prev;
140+
TreeNode* p;
141+
TreeNode* ans;
142+
143+
TreeNode* inorderSuccessor(TreeNode* root, TreeNode* p) {
144+
this->p = p;
145+
dfs(root);
146+
return ans;
147+
}
148+
149+
void dfs(TreeNode* root) {
150+
if (!root) return;
151+
dfs(root->left);
152+
if (prev == p) ans = root;
153+
prev = root;
154+
dfs(root->right);
155+
}
156+
};
157+
```
68158
159+
### **Go**
160+
161+
```go
162+
/**
163+
* Definition for a binary tree node.
164+
* type TreeNode struct {
165+
* Val int
166+
* Left *TreeNode
167+
* Right *TreeNode
168+
* }
169+
*/
170+
func inorderSuccessor(root *TreeNode, p *TreeNode) *TreeNode {
171+
var prev, ans *TreeNode
172+
var dfs func(root *TreeNode)
173+
dfs = func(root *TreeNode) {
174+
if root == nil {
175+
return
176+
}
177+
dfs(root.Left)
178+
if prev == p {
179+
ans = root
180+
}
181+
prev = root
182+
dfs(root.Right)
183+
}
184+
dfs(root)
185+
return ans
186+
}
69187
```
70188

71189
### **...**

‎lcci/04.06.Successor/Solution.cpp‎

Lines changed: 29 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,29 @@
1+
/**
2+
* Definition for a binary tree node.
3+
* struct TreeNode {
4+
* int val;
5+
* TreeNode *left;
6+
* TreeNode *right;
7+
* TreeNode(int x) : val(x), left(NULL), right(NULL) {}
8+
* };
9+
*/
10+
class Solution {
11+
public:
12+
TreeNode* prev;
13+
TreeNode* p;
14+
TreeNode* ans;
15+
16+
TreeNode* inorderSuccessor(TreeNode* root, TreeNode* p) {
17+
this->p = p;
18+
dfs(root);
19+
return ans;
20+
}
21+
22+
void dfs(TreeNode* root) {
23+
if (!root) return;
24+
dfs(root->left);
25+
if (prev == p) ans = root;
26+
prev = root;
27+
dfs(root->right);
28+
}
29+
};

‎lcci/04.06.Successor/Solution.go‎

Lines changed: 25 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,25 @@
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 inorderSuccessor(root *TreeNode, p *TreeNode) *TreeNode {
10+
var prev, ans *TreeNode
11+
var dfs func(root *TreeNode)
12+
dfs = func(root *TreeNode) {
13+
if root == nil {
14+
return
15+
}
16+
dfs(root.Left)
17+
if prev == p {
18+
ans = root
19+
}
20+
prev = root
21+
dfs(root.Right)
22+
}
23+
dfs(root)
24+
return ans
25+
}

‎lcci/04.06.Successor/Solution.java‎

Lines changed: 34 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,34 @@
1+
/**
2+
* Definition for a binary tree node.
3+
* public class TreeNode {
4+
* int val;
5+
* TreeNode left;
6+
* TreeNode right;
7+
* TreeNode(int x) { val = x; }
8+
* }
9+
*/
10+
class Solution {
11+
private TreeNode prev;
12+
private TreeNode p;
13+
private TreeNode ans;
14+
15+
public TreeNode inorderSuccessor(TreeNode root, TreeNode p) {
16+
prev = null;
17+
ans = null;
18+
this.p = p;
19+
dfs(root);
20+
return ans;
21+
}
22+
23+
private void dfs(TreeNode root) {
24+
if (root == null) {
25+
return;
26+
}
27+
dfs(root.left);
28+
if (prev == p) {
29+
ans = root;
30+
}
31+
prev = root;
32+
dfs(root.right);
33+
}
34+
}

‎lcci/04.06.Successor/Solution.py‎

Lines changed: 22 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,22 @@
1+
# Definition for a binary tree node.
2+
# class TreeNode:
3+
# def __init__(self, x):
4+
# self.val = x
5+
# self.left = None
6+
# self.right = None
7+
8+
class Solution:
9+
def inorderSuccessor(self, root: TreeNode, p: TreeNode) -> TreeNode:
10+
def dfs(root):
11+
if root is None:
12+
return
13+
dfs(root.left)
14+
nonlocal ans, prev
15+
if prev == p:
16+
ans = root
17+
prev = root
18+
dfs(root.right)
19+
20+
ans = prev = None
21+
dfs(root)
22+
return ans

0 commit comments

Comments
 (0)