learning
/
leetcode
mirror of https://github.com/doocs/leetcode.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

feat: update leetcode solutions: No.0144, No.0145

This commit is contained in:
yanglbme 2021-03-17 00:29:35 +08:00
parent d9c8ead4c4
commit 8cdca7cced
4 changed files with 297 additions and 2 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

80
solution/0100-0199/0144.Binary Tree Preorder Traversal/README.md
View File

@ -25,7 +25,16 @@
<!-- 这里可写通用的实现逻辑 -->
递归遍历。
递归遍历或利用栈实现非递归遍历。
非递归的思路如下：
1. 定义一个栈，先将根节点压入栈
2. 若栈不为空，每次从栈中弹出一个节点
3. 处理该节点
4. 先把节点右孩子压入栈，接着把节点左孩子压入栈（如果有孩子节点）
5. 重复 2-4
6. 返回结果
<!-- tabs:start -->
@ -33,6 +42,8 @@
<!-- 这里可写当前语言的特殊实现逻辑 -->
递归：
```python
# Definition for a binary tree node.
# class TreeNode:
@ -52,10 +63,36 @@ class Solution:
return res
```
非递归：
```python
# Definition for a binary tree node.
# class TreeNode:
# def __init__(self, val=0, left=None, right=None):
# self.val = val
# self.left = left
# self.right = right
class Solution:
def preorderTraversal(self, root: TreeNode) -> List[int]:
res = []
if root:
s = [root]
while s:
node = s.pop()
res.append(node.val)
if node.right:
s.append(node.right)
if node.left:
s.append(node.left)
return res
```
### **Java**
<!-- 这里可写当前语言的特殊实现逻辑 -->
递归：
```java
/**
* Definition for a binary tree node.
@ -92,6 +129,47 @@ class Solution {
}
```
非递归：
```java
/**
* Definition for a binary tree node.
* public class TreeNode {
* int val;
* TreeNode left;
* TreeNode right;
* TreeNode() {}
* TreeNode(int val) { this.val = val; }
* TreeNode(int val, TreeNode left, TreeNode right) {
* this.val = val;
* this.left = left;
* this.right = right;
* }
* }
*/
class Solution {
public List<Integer> preorderTraversal(TreeNode root) {
if (root == null) {
return Collections.emptyList();
}
List<Integer> res = new ArrayList<>();
Deque<TreeNode> s = new ArrayDeque<>();
s.push(root);
while (!s.isEmpty()) {
TreeNode node = s.pop();
res.add(node.val);
if (node.right != null) {
s.push(node.right);
}
if (node.left != null) {
s.push(node.left);
}
}
return res;
}
}
```
### **...**
```

69
solution/0100-0199/0144.Binary Tree Preorder Traversal/README_EN.md
View File

@ -36,6 +36,8 @@
### **Python3**
Recursive:
```python
# Definition for a binary tree node.
# class TreeNode:
@ -55,8 +57,34 @@ class Solution:
return res
```
Non-recursive:
```python
# Definition for a binary tree node.
# class TreeNode:
# def __init__(self, val=0, left=None, right=None):
# self.val = val
# self.left = left
# self.right = right
class Solution:
def preorderTraversal(self, root: TreeNode) -> List[int]:
res = []
if root:
s = [root]
while s:
node = s.pop()
res.append(node.val)
if node.right:
s.append(node.right)
if node.left:
s.append(node.left)
return res
```
### **Java**
Recursive:
```java
/**
* Definition for a binary tree node.
@ -93,6 +121,47 @@ class Solution {
}
```
Non-recursive:
```java
/**
* Definition for a binary tree node.
* public class TreeNode {
* int val;
* TreeNode left;
* TreeNode right;
* TreeNode() {}
* TreeNode(int val) { this.val = val; }
* TreeNode(int val, TreeNode left, TreeNode right) {
* this.val = val;
* this.left = left;
* this.right = right;
* }
* }
*/
class Solution {
public List<Integer> preorderTraversal(TreeNode root) {
if (root == null) {
return Collections.emptyList();
}
List<Integer> res = new ArrayList<>();
Deque<TreeNode> s = new ArrayDeque<>();
s.push(root);
while (!s.isEmpty()) {
TreeNode node = s.pop();
res.add(node.val);
if (node.right != null) {
s.push(node.right);
}
if (node.left != null) {
s.push(node.left);
}
}
return res;
}
}
```
### **...**
```

79
solution/0100-0199/0145.Binary Tree Postorder Traversal/README.md
View File

@ -24,7 +24,13 @@
<!-- 这里可写通用的实现逻辑 -->
递归遍历。
递归遍历或利用栈实现非递归遍历。
非递归的思路如下：
先序遍历的顺序是：头、左、右，如果我们改变左右孩子的顺序，就能将顺序变成：头、右、左。
我们先不打印头节点，而是存放到另一个收集栈 s2 中，最后遍历结束，输出收集栈元素，即是后序遍历：左、右、头。
<!-- tabs:start -->
@ -32,6 +38,8 @@
<!-- 这里可写当前语言的特殊实现逻辑 -->
递归：
```python
# Definition for a binary tree node.
# class TreeNode:
@ -51,10 +59,37 @@ class Solution:
return res
```
非递归：
```python
# Definition for a binary tree node.
# class TreeNode:
# def __init__(self, val=0, left=None, right=None):
# self.val = val
# self.left = left
# self.right = right
class Solution:
def postorderTraversal(self, root: TreeNode) -> List[int]:
if not root:
return []
s1 = [root]
s2 = []
while s1:
node = s1.pop()
s2.append(node.val)
if node.left:
s1.append(node.left)
if node.right:
s1.append(node.right)
return s2[::-1]
```
### **Java**
<!-- 这里可写当前语言的特殊实现逻辑 -->
递归：
```java
/**
* Definition for a binary tree node.
@ -91,6 +126,48 @@ class Solution {
}
```
非递归：
```java
/**
* Definition for a binary tree node.
* public class TreeNode {
* int val;
* TreeNode left;
* TreeNode right;
* TreeNode() {}
* TreeNode(int val) { this.val = val; }
* TreeNode(int val, TreeNode left, TreeNode right) {
* this.val = val;
* this.left = left;
* this.right = right;
* }
* }
*/
class Solution {
public List<Integer> postorderTraversal(TreeNode root) {
if (root == null) {
return Collections.emptyList();
}
Deque<TreeNode> s1 = new ArrayDeque<>();
List<Integer> s2 = new ArrayList<>();
s1.push(root);
while (!s1.isEmpty()) {
TreeNode node = s1.pop();
s2.add(node.val);
if (node.left != null) {
s1.push(node.left);
}
if (node.right != null) {
s1.push(node.right);
}
}
Collections.reverse(s2);
return s2;
}
}
```
### **...**
```

71
solution/0100-0199/0145.Binary Tree Postorder Traversal/README_EN.md
View File

@ -36,6 +36,8 @@
### **Python3**
Recursive:
```python
# Definition for a binary tree node.
# class TreeNode:
@ -55,8 +57,35 @@ class Solution:
return res
```
Non-recursive:
```python
# Definition for a binary tree node.
# class TreeNode:
# def __init__(self, val=0, left=None, right=None):
# self.val = val
# self.left = left
# self.right = right
class Solution:
def postorderTraversal(self, root: TreeNode) -> List[int]:
if not root:
return []
s1 = [root]
s2 = []
while s1:
node = s1.pop()
s2.append(node.val)
if node.left:
s1.append(node.left)
if node.right:
s1.append(node.right)
return s2[::-1]
```
### **Java**
Recursive:
```java
/**
* Definition for a binary tree node.
@ -93,6 +122,48 @@ class Solution {
}
```
Non-recursive:
```java
/**
* Definition for a binary tree node.
* public class TreeNode {
* int val;
* TreeNode left;
* TreeNode right;
* TreeNode() {}
* TreeNode(int val) { this.val = val; }
* TreeNode(int val, TreeNode left, TreeNode right) {
* this.val = val;
* this.left = left;
* this.right = right;
* }
* }
*/
class Solution {
public List<Integer> postorderTraversal(TreeNode root) {
if (root == null) {
return Collections.emptyList();
}
Deque<TreeNode> s1 = new ArrayDeque<>();
List<Integer> s2 = new ArrayList<>();
s1.push(root);
while (!s1.isEmpty()) {
TreeNode node = s1.pop();
s2.add(node.val);
if (node.left != null) {
s1.push(node.left);
}
if (node.right != null) {
s1.push(node.right);
}
}
Collections.reverse(s2);
return s2;
}
}
```
### **...**
```