algorithm/leetcode-master
1
0
Fork 0
mirror of https://github.com/youngyangyang04/leetcode-master.git synced 2025-07-09 02:53:31 +08:00
Code Issues Packages Projects Releases Wiki Activity

update 0226.翻转二叉树: 优化代码风格

Browse Source
This commit is contained in:
Yuhao Ju
2022-11-29 14:41:26 +08:00
committed by GitHub
parent 26aec30440
commit 8ca827b6f9
1 changed files with 89 additions and 90 deletions
Download Patch File Download Diff File Expand all files Collapse all files

179
problems/0226.翻转二叉树.md
View File

@ -104,7 +104,7 @@ public:
### 深度优先遍历 ### 深度优先遍历
[二叉树：听说递归能做的，栈也能做！](https://programmercarl.com/二叉树的迭代遍历.html)中给出了前中后序迭代方式的写法，所以本地可以很轻松的切出如下迭代法的代码： [二叉树：听说递归能做的，栈也能做！](https://programmercarl.com/二叉树的迭代遍历.html)中给出了前中后序迭代方式的写法，所以本题可以很轻松的写出如下迭代法的代码：
C++代码迭代法（前序遍历） C++代码迭代法（前序遍历）
@ -126,7 +126,7 @@ public:
} }
}; };
``` ```
如果这个代码看不懂的话可以在回顾一下[二叉树：听说递归能做的，栈也能做！](https://programmercarl.com/二叉树的迭代遍历.html)。 如果这个代码看不懂的话可以再回顾一下[二叉树：听说递归能做的，栈也能做！](https://programmercarl.com/二叉树的迭代遍历.html)。
我们在[二叉树：前中后序迭代方式的统一写法](https://programmercarl.com/二叉树的统一迭代法.html)中介绍了统一的写法，所以，本题也只需将文中的代码少做修改便可。 我们在[二叉树：前中后序迭代方式的统一写法](https://programmercarl.com/二叉树的统一迭代法.html)中介绍了统一的写法，所以，本题也只需将文中的代码少做修改便可。
@ -257,8 +257,7 @@ public:
## 其他语言版本 ## 其他语言版本
### Java Java
```Java ```Java
//DFS递归 //DFS递归
class Solution { class Solution {
@ -294,8 +293,8 @@ class Solution {
while (size-- > 0) { while (size-- > 0) {
TreeNode node = deque.poll(); TreeNode node = deque.poll();
swap(node); swap(node);
if (node.left != null) {deque.offer(node.left);} if (node.left != null) deque.offer(node.left);
if (node.right != null) {deque.offer(node.right);} if (node.right != null) deque.offer(node.right);
} }
} }
return root; return root;
@ -309,7 +308,7 @@ class Solution {
} }
``` ```
### Python Python
递归法：前序遍历： 递归法：前序遍历：
```python ```python
@ -361,16 +360,15 @@ class Solution:
return root return root
``` ```
### Go Go
递归版本的前序遍历 递归版本的前序遍历
```Go ```Go
func invertTree(root *TreeNode) *TreeNode { func invertTree(root *TreeNode) *TreeNode {
if root ==nil{ if root == nil {
return nil return nil
} }
root.Left,root.Right=root.Right,root.Left//交换 root.Left, root.Right = root.Right, root.Left //交换
invertTree(root.Left) invertTree(root.Left)
invertTree(root.Right) invertTree(root.Right)
@ -383,12 +381,14 @@ func invertTree(root *TreeNode) *TreeNode {
```go ```go
func invertTree(root *TreeNode) *TreeNode { func invertTree(root *TreeNode) *TreeNode {
if root==nil{ if root == nil {
return root return root
} }
invertTree(root.Left)//遍历左节点
invertTree(root.Right)//遍历右节点 invertTree(root.Left) //遍历左节点
root.Left,root.Right=root.Right,root.Left//交换 invertTree(root.Right) //遍历右节点
root.Left, root.Right = root.Right, root.Left //交换
return root return root
} }
``` ```
@ -397,18 +397,19 @@ func invertTree(root *TreeNode) *TreeNode {
```go ```go
func invertTree(root *TreeNode) *TreeNode { func invertTree(root *TreeNode) *TreeNode {
stack:=[]*TreeNode{} stack := []*TreeNode{}
node:=root node := root
for node!=nil||len(stack)>0{ for node != nil || len(stack) > 0 {
for node!=nil{ for node != nil {
node.Left,node.Right=node.Right,node.Left//交换 node.Left, node.Right = node.Right, node.Left //交换
stack=append(stack,node) stack = append(stack,node)
node=node.Left node = node.Left
} }
node=stack[len(stack)-1] node = stack[len(stack)-1]
stack=stack[:len(stack)-1] stack = stack[:len(stack)-1]
node=node.Right node = node.Right
} }
return root return root
} }
``` ```
@ -417,25 +418,26 @@ func invertTree(root *TreeNode) *TreeNode {
```go ```go
func invertTree(root *TreeNode) *TreeNode { func invertTree(root *TreeNode) *TreeNode {
stack:=[]*TreeNode{} stack := []*TreeNode{}
node:=root node := root
var prev *TreeNode var prev *TreeNode
for node!=nil||len(stack)>0{ for node != nil || len(stack) > 0 {
for node!=nil{ for node != nil {
stack=append(stack,node) stack = append(stack, node)
node=node.Left node = node.Left
} }
node=stack[len(stack)-1] node = stack[len(stack)-1]
stack=stack[:len(stack)-1] stack = stack[:len(stack)-1]
if node.Right==nil||node.Right==prev{ if node.Right == nil || node.Right == prev {
node.Left,node.Right=node.Right,node.Left//交换 node.Left, node.Right = node.Right, node.Left //交换
prev=node prev = node
node=nil node = nil
}else { } else {
stack=append(stack,node) stack = append(stack, node)
node=node.Right node = node.Right
} }
} }
return root return root
} }
``` ```
@ -444,21 +446,21 @@ func invertTree(root *TreeNode) *TreeNode {
```go ```go
func invertTree(root *TreeNode) *TreeNode { func invertTree(root *TreeNode) *TreeNode {
if root==nil{ if root == nil{
return root return root
} }
queue:=list.New() queue := list.New()
node:=root node := root
queue.PushBack(node) queue.PushBack(node)
for queue.Len()>0{ for queue.Len() > 0 {
length:=queue.Len() length := queue.Len()
for i:=0;i<length;i++{ for i := 0; i < length; i++ {
e:=queue.Remove(queue.Front()).(*TreeNode) e := queue.Remove(queue.Front()).(*TreeNode)
e.Left,e.Right=e.Right,e.Left//交换 e.Left, e.Right = e.Right, e.Left //交换
if e.Left!=nil{ if e.Left != nil {
queue.PushBack(e.Left) queue.PushBack(e.Left)
} }
if e.Right!=nil{ if e.Right != nil {
queue.PushBack(e.Right) queue.PushBack(e.Right)
} }
} }
@ -467,7 +469,7 @@ func invertTree(root *TreeNode) *TreeNode {
} }
``` ```
### JavaScript JavaScript
使用递归版本的前序遍历 使用递归版本的前序遍历
```javascript ```javascript
@ -487,31 +489,31 @@ var invertTree = function(root) {
```javascript ```javascript
var invertTree = function(root) { var invertTree = function(root) {
//我们先定义节点交换函数 //我们先定义节点交换函数
const invertNode=function(root,left,right){ const invertNode = function(root, left, right) {
let temp=left; let temp = left;
left=right; left = right;
right=temp; right = temp;
root.left=left; root.left = left;
root.right=right; root.right = right;
} }
//使用迭代方法的前序遍历 //使用迭代方法的前序遍历
let stack=[]; let stack = [];
if(root===null){ if(root === null) {
return root; return root;
} }
stack.push(root); stack.push(root);
while(stack.length){ while(stack.length) {
let node=stack.pop(); let node = stack.pop();
if(node!==null){ if(node !== null) {
//前序遍历顺序中左右 入栈顺序是前序遍历的倒序右左中 //前序遍历顺序中左右 入栈顺序是前序遍历的倒序右左中
node.right&&stack.push(node.right); node.right && stack.push(node.right);
node.left&&stack.push(node.left); node.left && stack.push(node.left);
stack.push(node); stack.push(node);
stack.push(null); stack.push(null);
}else{ } else {
node=stack.pop(); node = stack.pop();
//节点处理逻辑 //节点处理逻辑
invertNode(node,node.left,node.right); invertNode(node, node.left, node.right);
} }
} }
return root; return root;
@ -521,34 +523,34 @@ var invertTree = function(root) {
```javascript ```javascript
var invertTree = function(root) { var invertTree = function(root) {
//我们先定义节点交换函数 //我们先定义节点交换函数
const invertNode=function(root,left,right){ const invertNode = function(root, left, right) {
let temp=left; let temp = left;
left=right; left = right;
right=temp; right = temp;
root.left=left; root.left = left;
root.right=right; root.right = right;
} }
//使用层序遍历 //使用层序遍历
let queue=[]; let queue = [];
if(root===null){ if(root === null) {
return root; return root;
} }
queue.push(root); queue.push(root);
while(queue.length){ while(queue.length) {
let length=queue.length; let length = queue.length;
while(length--){ while(length--) {
let node=queue.shift(); let node = queue.shift();
//节点处理逻辑 //节点处理逻辑
invertNode(node,node.left,node.right); invertNode(node, node.left, node.right);
node.left&&queue.push(node.left); node.left && queue.push(node.left);
node.right&&queue.push(node.right); node.right && queue.push(node.right);
} }
} }
return root; return root;
}; };
``` ```
### TypeScript： TypeScript：
递归法： 递归法：
@ -675,7 +677,7 @@ function invertTree(root: TreeNode | null): TreeNode | null {
}; };
``` ```
### C C
递归法 递归法
```c ```c
@ -722,7 +724,7 @@ struct TreeNode* invertTree(struct TreeNode* root){
} }
``` ```
### Swift： Swift：
```swift ```swift
// 前序遍历-递归 // 前序遍历-递归
func invertTree(_ root: TreeNode?) -> TreeNode? { func invertTree(_ root: TreeNode?) -> TreeNode? {
@ -760,7 +762,7 @@ func invertTree1(_ root: TreeNode?) -> TreeNode? {
} }
``` ```
### Swift Swift
深度优先递归。 深度优先递归。
@ -808,9 +810,6 @@ func invertTree(_ root: TreeNode?) -> TreeNode? {
return root return root
} }
``` ```
### Scala
深度优先遍历（前序遍历）: 深度优先遍历（前序遍历）:
```scala ```scala
object Solution { object Solution {
@ -857,7 +856,7 @@ object Solution {
} }
``` ```
### rust rust
```rust ```rust
impl Solution { impl Solution {