Skip to content

Commit b87e47a

Browse files
yanglbmeyanglbme
committed
feat: add solutions to lc problems
* No.0958.Check Completeness of a Binary Tree * No.1971.Find if Path Exists in Graph
1 parent fd33d1f commit b87e47a

File tree

12 files changed

+560
-17
lines changed

12 files changed

+560
-17
lines changed

‎solution/0900-0999/0958.Check Completeness of a Binary Tree/README.md

+102-1
Original file line numberDiff line numberDiff line change
@@ -52,15 +52,116 @@
5252
<!-- 这里可写当前语言的特殊实现逻辑 -->
5353

5454
```python
55-
55+
# Definition for a binary tree node.
56+
# class TreeNode:
57+
# def __init__(self, val=0, left=None, right=None):
58+
# self.val = val
59+
# self.left = left
60+
# self.right = right
61+
class Solution:
62+
def isCompleteTree(self, root: TreeNode) -> bool:
63+
q = deque([root])
64+
while q:
65+
node = q.popleft()
66+
if node is None:
67+
break
68+
q.append(node.left)
69+
q.append(node.right)
70+
return all(node is None for node in q)
5671
```
5772

5873
### **Java**
5974

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

6277
```java
78+
/**
79+
* Definition for a binary tree node.
80+
* public class TreeNode {
81+
* int val;
82+
* TreeNode left;
83+
* TreeNode right;
84+
* TreeNode() {}
85+
* TreeNode(int val) { this.val = val; }
86+
* TreeNode(int val, TreeNode left, TreeNode right) {
87+
* this.val = val;
88+
* this.left = left;
89+
* this.right = right;
90+
* }
91+
* }
92+
*/
93+
class Solution {
94+
public boolean isCompleteTree(TreeNode root) {
95+
Deque<TreeNode> q = new LinkedList<>();
96+
q.offer(root);
97+
while (q.peek() != null) {
98+
TreeNode node = q.poll();
99+
q.offer(node.left);
100+
q.offer(node.right);
101+
}
102+
while (!q.isEmpty() && q.peek() == null) {
103+
q.poll();
104+
}
105+
return q.isEmpty();
106+
}
107+
}
108+
```
109+
110+
### **C++**
111+
112+
```cpp
113+
/**
114+
* Definition for a binary tree node.
115+
* struct TreeNode {
116+
* int val;
117+
* TreeNode *left;
118+
* TreeNode *right;
119+
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
120+
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
121+
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
122+
* };
123+
*/
124+
class Solution {
125+
public:
126+
bool isCompleteTree(TreeNode* root) {
127+
queue<TreeNode*> q{{root}};
128+
while (q.front())
129+
{
130+
root = q.front();
131+
q.pop();
132+
q.push(root->left);
133+
q.push(root->right);
134+
}
135+
while (!q.empty() && !q.front()) q.pop();
136+
return q.empty();
137+
}
138+
};
139+
```
63140
141+
### **Go**
142+
143+
```go
144+
/**
145+
* Definition for a binary tree node.
146+
* type TreeNode struct {
147+
* Val int
148+
* Left *TreeNode
149+
* Right *TreeNode
150+
* }
151+
*/
152+
func isCompleteTree(root *TreeNode) bool {
153+
q := []*TreeNode{root}
154+
for q[0] != nil {
155+
root = q[0]
156+
q = q[1:]
157+
q = append(q, root.Left)
158+
q = append(q, root.Right)
159+
}
160+
for len(q) > 0 && q[0] == nil {
161+
q = q[1:]
162+
}
163+
return len(q) == 0
164+
}
64165
```
65166

66167
### **...**

‎solution/0900-0999/0958.Check Completeness of a Binary Tree/README_EN.md

+102-1
Original file line numberDiff line numberDiff line change
@@ -40,13 +40,114 @@
4040
### **Python3**
4141

4242
```python
43-
43+
# Definition for a binary tree node.
44+
# class TreeNode:
45+
# def __init__(self, val=0, left=None, right=None):
46+
# self.val = val
47+
# self.left = left
48+
# self.right = right
49+
class Solution:
50+
def isCompleteTree(self, root: TreeNode) -> bool:
51+
q = deque([root])
52+
while q:
53+
node = q.popleft()
54+
if node is None:
55+
break
56+
q.append(node.left)
57+
q.append(node.right)
58+
return all(node is None for node in q)
4459
```
4560

4661
### **Java**
4762

4863
```java
64+
/**
65+
* Definition for a binary tree node.
66+
* public class TreeNode {
67+
* int val;
68+
* TreeNode left;
69+
* TreeNode right;
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+
* }
77+
* }
78+
*/
79+
class Solution {
80+
public boolean isCompleteTree(TreeNode root) {
81+
Deque<TreeNode> q = new LinkedList<>();
82+
q.offer(root);
83+
while (q.peek() != null) {
84+
TreeNode node = q.poll();
85+
q.offer(node.left);
86+
q.offer(node.right);
87+
}
88+
while (!q.isEmpty() && q.peek() == null) {
89+
q.poll();
90+
}
91+
return q.isEmpty();
92+
}
93+
}
94+
```
95+
96+
### **C++**
97+
98+
```cpp
99+
/**
100+
* Definition for a binary tree node.
101+
* struct TreeNode {
102+
* int val;
103+
* TreeNode *left;
104+
* TreeNode *right;
105+
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
106+
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
107+
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
108+
* };
109+
*/
110+
class Solution {
111+
public:
112+
bool isCompleteTree(TreeNode* root) {
113+
queue<TreeNode*> q{{root}};
114+
while (q.front())
115+
{
116+
root = q.front();
117+
q.pop();
118+
q.push(root->left);
119+
q.push(root->right);
120+
}
121+
while (!q.empty() && !q.front()) q.pop();
122+
return q.empty();
123+
}
124+
};
125+
```
49126
127+
### **Go**
128+
129+
```go
130+
/**
131+
* Definition for a binary tree node.
132+
* type TreeNode struct {
133+
* Val int
134+
* Left *TreeNode
135+
* Right *TreeNode
136+
* }
137+
*/
138+
func isCompleteTree(root *TreeNode) bool {
139+
q := []*TreeNode{root}
140+
for q[0] != nil {
141+
root = q[0]
142+
q = q[1:]
143+
q = append(q, root.Left)
144+
q = append(q, root.Right)
145+
}
146+
for len(q) > 0 && q[0] == nil {
147+
q = q[1:]
148+
}
149+
return len(q) == 0
150+
}
50151
```
51152

52153
### **...**

‎solution/0900-0999/0958.Check Completeness of a Binary Tree/Solution.cpp

+26
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,26 @@
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+
bool isCompleteTree(TreeNode* root) {
15+
queue<TreeNode*> q{{root}};
16+
while (q.front())
17+
{
18+
root = q.front();
19+
q.pop();
20+
q.push(root->left);
21+
q.push(root->right);
22+
}
23+
while (!q.empty() && !q.front()) q.pop();
24+
return q.empty();
25+
}
26+
};

‎solution/0900-0999/0958.Check Completeness of a Binary Tree/Solution.go

+21
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,21 @@
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 isCompleteTree(root *TreeNode) bool {
10+
q := []*TreeNode{root}
11+
for q[0] != nil {
12+
root = q[0]
13+
q = q[1:]
14+
q = append(q, root.Left)
15+
q = append(q, root.Right)
16+
}
17+
for len(q) > 0 && q[0] == nil {
18+
q = q[1:]
19+
}
20+
return len(q) == 0
21+
}

‎solution/0900-0999/0958.Check Completeness of a Binary Tree/Solution.java

+30-15
Original file line numberDiff line numberDiff line change
@@ -1,15 +1,30 @@
1-
class Solution {
2-
public boolean isCompleteTree(TreeNode root) {
3-
Queue<TreeNode> queue = new LinkedList<>();
4-
queue.offer(root);
5-
while (queue.peek() != null) {
6-
TreeNode node = queue.poll();
7-
queue.offer(node.left);
8-
queue.offer(node.right);
9-
}
10-
while (!queue.isEmpty() && queue.peek() == null) {
11-
queue.poll();
12-
}
13-
return queue.isEmpty();
14-
}
15-
}
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+
public boolean isCompleteTree(TreeNode root) {
18+
Deque<TreeNode> q = new LinkedList<>();
19+
q.offer(root);
20+
while (q.peek() != null) {
21+
TreeNode node = q.poll();
22+
q.offer(node.left);
23+
q.offer(node.right);
24+
}
25+
while (!q.isEmpty() && q.peek() == null) {
26+
q.poll();
27+
}
28+
return q.isEmpty();
29+
}
30+
}

‎solution/0900-0999/0958.Check Completeness of a Binary Tree/Solution.py

+16
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,16 @@
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 isCompleteTree(self, root: TreeNode) -> bool:
9+
q = deque([root])
10+
while q:
11+
node = q.popleft()
12+
if node is None:
13+
break
14+
q.append(node.left)
15+
q.append(node.right)
16+
return all(node is None for node in q)

0 commit comments

Comments
 (0)