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

This commit is contained in:
Yuhao Ju
2022-11-29 14:41:26 +08:00
committed by GitHub
parent 26aec30440
commit 8ca827b6f9

View File

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