Skip to content

Commit cde693c

Browse files
yanglbmeyanglbme
committed
feat: add solutions to lc problem: No.1372
No.1372.Longest ZigZag Path in a Binary Tree
1 parent 54858fa commit cde693c

File tree

7 files changed

+345
-4
lines changed

7 files changed

+345
-4
lines changed

‎solution/1300-1399/1372.Longest ZigZag Path in a Binary Tree/README.md

Lines changed: 120 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -58,22 +58,141 @@
5858

5959
<!-- 这里可写通用的实现逻辑 -->
6060

61+
**方法一：DFS**
62+
63+
时间复杂度 $O(n)$，其中 $n$ 是树中节点的个数。
64+
6165
<!-- tabs:start -->
6266

6367
### **Python3**
6468

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

6771
```python
68-
72+
# Definition for a binary tree node.
73+
# class TreeNode:
74+
# def __init__(self, val=0, left=None, right=None):
75+
# self.val = val
76+
# self.left = left
77+
# self.right = right
78+
class Solution:
79+
def longestZigZag(self, root: TreeNode) -> int:
80+
def dfs(root, l, r):
81+
if root is None:
82+
return
83+
nonlocal ans
84+
ans = max(ans, l, r)
85+
dfs(root.left, r + 1, 0)
86+
dfs(root.right, 0, l + 1)
87+
88+
ans = 0
89+
dfs(root, 0, 0)
90+
return ans
6991
```
7092

7193
### **Java**
7294

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

7597
```java
98+
/**
99+
* Definition for a binary tree node.
100+
* public class TreeNode {
101+
* int val;
102+
* TreeNode left;
103+
* TreeNode right;
104+
* TreeNode() {}
105+
* TreeNode(int val) { this.val = val; }
106+
* TreeNode(int val, TreeNode left, TreeNode right) {
107+
* this.val = val;
108+
* this.left = left;
109+
* this.right = right;
110+
* }
111+
* }
112+
*/
113+
class Solution {
114+
private int ans;
115+
116+
public int longestZigZag(TreeNode root) {
117+
dfs(root, 0, 0);
118+
return ans;
119+
}
120+
121+
private void dfs(TreeNode root, int l, int r) {
122+
if (root == null) {
123+
return;
124+
}
125+
ans = Math.max(ans, Math.max(l, r));
126+
dfs(root.left, r + 1, 0);
127+
dfs(root.right, 0, l + 1);
128+
}
129+
}
130+
```
131+
132+
### **C++**
133+
134+
```cpp
135+
/**
136+
* Definition for a binary tree node.
137+
* struct TreeNode {
138+
* int val;
139+
* TreeNode *left;
140+
* TreeNode *right;
141+
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
142+
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
143+
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
144+
* };
145+
*/
146+
class Solution {
147+
public:
148+
int ans = 0;
149+
150+
int longestZigZag(TreeNode* root) {
151+
dfs(root, 0, 0);
152+
return ans;
153+
}
154+
155+
void dfs(TreeNode* root, int l, int r) {
156+
if (!root) return;
157+
ans = max(ans, max(l, r));
158+
dfs(root->left, r + 1, 0);
159+
dfs(root->right, 0, l + 1);
160+
}
161+
};
162+
```
76163
164+
### **Go**
165+
166+
```go
167+
/**
168+
* Definition for a binary tree node.
169+
* type TreeNode struct {
170+
* Val int
171+
* Left *TreeNode
172+
* Right *TreeNode
173+
* }
174+
*/
175+
func longestZigZag(root *TreeNode) int {
176+
ans := 0
177+
var dfs func(root *TreeNode, l, r int)
178+
dfs = func(root *TreeNode, l, r int) {
179+
if root == nil {
180+
return
181+
}
182+
ans = max(ans, max(l, r))
183+
dfs(root.Left, r+1, 0)
184+
dfs(root.Right, 0, l+1)
185+
}
186+
dfs(root, 0, 0)
187+
return ans
188+
}
189+
190+
func max(a, b int) int {
191+
if a > b {
192+
return a
193+
}
194+
return b
195+
}
77196
```
78197

79198
### **...**

‎solution/1300-1399/1372.Longest ZigZag Path in a Binary Tree/README_EN.md

Lines changed: 116 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -58,13 +58,128 @@
5858
### **Python3**
5959

6060
```python
61-
61+
# Definition for a binary tree node.
62+
# class TreeNode:
63+
# def __init__(self, val=0, left=None, right=None):
64+
# self.val = val
65+
# self.left = left
66+
# self.right = right
67+
class Solution:
68+
def longestZigZag(self, root: TreeNode) -> int:
69+
def dfs(root, l, r):
70+
if root is None:
71+
return
72+
nonlocal ans
73+
ans = max(ans, l, r)
74+
dfs(root.left, r + 1, 0)
75+
dfs(root.right, 0, l + 1)
76+
77+
ans = 0
78+
dfs(root, 0, 0)
79+
return ans
6280
```
6381

6482
### **Java**
6583

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

70185
### **...**

‎solution/1300-1399/1372.Longest ZigZag Path in a Binary Tree/Solution.cpp

Lines changed: 27 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,27 @@
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+
*/
12+
class Solution {
13+
public:
14+
int ans = 0;
15+
16+
int longestZigZag(TreeNode* root) {
17+
dfs(root, 0, 0);
18+
return ans;
19+
}
20+
21+
void dfs(TreeNode* root, int l, int r) {
22+
if (!root) return;
23+
ans = max(ans, max(l, r));
24+
dfs(root->left, r + 1, 0);
25+
dfs(root->right, 0, l + 1);
26+
}
27+
};

‎solution/1300-1399/1372.Longest ZigZag Path in a Binary Tree/Solution.go

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+
* type TreeNode struct {
4+
* Val int
5+
* Left *TreeNode
6+
* Right *TreeNode
7+
* }
8+
*/
9+
func longestZigZag(root *TreeNode) int {
10+
ans := 0
11+
var dfs func(root *TreeNode, l, r int)
12+
dfs = func(root *TreeNode, l, r int) {
13+
if root == nil {
14+
return
15+
}
16+
ans = max(ans, max(l, r))
17+
dfs(root.Left, r+1, 0)
18+
dfs(root.Right, 0, l+1)
19+
}
20+
dfs(root, 0, 0)
21+
return ans
22+
}
23+
24+
func max(a, b int) int {
25+
if a > b {
26+
return a
27+
}
28+
return b
29+
}

‎solution/1300-1399/1372.Longest ZigZag Path in a Binary Tree/Solution.java

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

‎solution/1300-1399/1372.Longest ZigZag Path in a Binary Tree/Solution.py

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

0 commit comments

Comments
 (0)