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

update 0102.二叉树的层序遍历: 优化 js 和 go 的代码风格

Browse Source
This commit is contained in:
Yuhao Ju
2022-11-29 14:03:05 +08:00
committed by GitHub
parent 16434b0491
commit 26aec30440
1 changed files with 267 additions and 253 deletions
Download Patch File Download Diff File Expand all files Collapse all files

520
problems/0102.二叉树的层序遍历.md
View File

@ -47,7 +47,7 @@
层序遍历一个二叉树。就是从左到右一层一层的去遍历二叉树。这种遍历的方式和我们之前讲过的都不太一样。
需要借用一个辅助数据结构即队列来实现，**队列先进先出，符合一层一层遍历的逻辑，而是用栈先进后出适合模拟深度优先遍历也就是递归的逻辑。**
需要借用一个辅助数据结构即队列来实现，**队列先进先出，符合一层一层遍历的逻辑，而用栈先进后出适合模拟深度优先遍历也就是递归的逻辑。**
**而这种层序遍历方式就是图论中的广度优先遍历，只不过我们应用在二叉树上。**
@ -106,50 +106,6 @@ public:
};
```
python3代码：
```python
class Solution:
"""二叉树层序遍历迭代解法"""
def levelOrder(self, root: TreeNode) -> List[List[int]]:
results = []
if not root:
return results
from collections import deque
que = deque([root])
while que:
size = len(que)
result = []
for _ in range(size):
cur = que.popleft()
result.append(cur.val)
if cur.left:
que.append(cur.left)
if cur.right:
que.append(cur.right)
results.append(result)
return results
```
```python
# 递归法
class Solution:
def levelOrder(self, root: TreeNode) -> List[List[int]]:
res = []
def helper(root, depth):
if not root: return []
if len(res) == depth: res.append([]) # start the current depth
res[depth].append(root.val) # fulfil the current depth
if root.left: helper(root.left, depth + 1) # process child nodes for the next depth
if root.right: helper(root.right, depth + 1)
helper(root, 0)
return res
```
java:
```Java
@ -206,6 +162,51 @@ class Solution {
}
```
python3代码：
```python
class Solution:
"""二叉树层序遍历迭代解法"""
def levelOrder(self, root: TreeNode) -> List[List[int]]:
results = []
if not root:
return results
from collections import deque
que = deque([root])
while que:
size = len(que)
result = []
for _ in range(size):
cur = que.popleft()
result.append(cur.val)
if cur.left:
que.append(cur.left)
if cur.right:
que.append(cur.right)
results.append(result)
return results
```
```python
# 递归法
class Solution:
def levelOrder(self, root: TreeNode) -> List[List[int]]:
res = []
def helper(root, depth):
if not root: return []
if len(res) == depth: res.append([]) # start the current depth
res[depth].append(root.val) # fulfil the current depth
if root.left: helper(root.left, depth + 1) # process child nodes for the next depth
if root.right: helper(root.right, depth + 1)
helper(root, 0)
return res
```
go:
```go
@ -243,28 +244,31 @@ func levelOrder(root *TreeNode) [][]int {
102. 二叉树的层序遍历
*/
func levelOrder(root *TreeNode) [][]int {
res:=[][]int{}
if root==nil{//防止为空
res := [][]int{}
if root == nil{//防止为空
return res
}
queue:=list.New()
queue := list.New()
queue.PushBack(root)
var tmpArr []int
for queue.Len()>0 {
length:=queue.Len()//保存当前层的长度，然后处理当前层（十分重要，防止添加下层元素影响判断层中元素的个数）
for i:=0;i<length;i++{
node:=queue.Remove(queue.Front()).(*TreeNode)//出队列
if node.Left!=nil{
for queue.Len() > 0 {
length := queue.Len() //保存当前层的长度，然后处理当前层（十分重要，防止添加下层元素影响判断层中元素的个数）
for i := 0; i < length; i++ {
node := queue.Remove(queue.Front()).(*TreeNode) //出队列
if node.Left != nil {
queue.PushBack(node.Left)
}
if node.Right!=nil{
if node.Right != nil {
queue.PushBack(node.Right)
}
tmpArr=append(tmpArr,node.Val)//将值加入本层切片中
tmpArr = append(tmpArr, node.Val) //将值加入本层切片中
}
res=append(res,tmpArr)//放入结果集
tmpArr=[]int{}//清空层的数据
res = append(res, tmpArr) //放入结果集
tmpArr = []int{} //清空层的数据
}
return res
}
```
@ -274,22 +278,22 @@ javascript代码：
```javascript
var levelOrder = function(root) {
//二叉树的层序遍历
let res=[],queue=[];
let res = [], queue = [];
queue.push(root);
if(root===null){
if(root === null) {
return res;
}
while(queue.length!==0){
while(queue.length !== 0) {
// 记录当前层级节点数
let length=queue.length;
let length = queue.length;
//存放每一层的节点
let curLevel=[];
for(let i=0;i<length;i++){
let node=queue.shift();
let curLevel = [];
for(let i = 0;i < length; i++) {
let node = queue.shift();
curLevel.push(node.val);
// 存放当前层下一层的节点
node.left&&queue.push(node.left);
node.right&&queue.push(node.right);
node.left && queue.push(node.left);
node.right && queue.push(node.right);
}
//把每一层的结果放到结果数组
res.push(curLevel);
@ -535,31 +539,34 @@ go:
107. 二叉树的层序遍历 II
*/
func levelOrderBottom(root *TreeNode) [][]int {
queue:=list.New()
res:=[][]int{}
if root==nil{
queue := list.New()
res := [][]int{}
if root == nil{
return res
}
queue.PushBack(root)
for queue.Len()>0{
length:=queue.Len()
tmp:=[]int{}
for i:=0;i<length;i++{
node:=queue.Remove(queue.Front()).(*TreeNode)
if node.Left!=nil{
for queue.Len() > 0 {
length := queue.Len()
tmp := []int{}
for i := 0; i < length; i++ {
node := queue.Remove(queue.Front()).(*TreeNode)
if node.Left != nil {
queue.PushBack(node.Left)
}
if node.Right!=nil{
if node.Right != nil {
queue.PushBack(node.Right)
}
tmp=append(tmp,node.Val)
tmp = append(tmp, node.Val)
}
res=append(res,tmp)
res=append(res, tmp)
}
//反转结果集
for i:=0;i<len(res)/2;i++{
res[i],res[len(res)-i-1]=res[len(res)-i-1],res[i]
for i:=0; i<len(res)/2; i++ {
res[i], res[len(res)-i-1] = res[len(res)-i-1], res[i]
}
return res
}
```
@ -568,20 +575,20 @@ javascript代码
```javascript
var levelOrderBottom = function(root) {
let res=[],queue=[];
let res = [], queue = [];
queue.push(root);
while(queue.length&&root!==null){
while(queue.length && root!==null) {
// 存放当前层级节点数组
let curLevel=[];
let curLevel = [];
// 计算当前层级节点数量
let length=queue.length;
while(length--){
let node=queue.shift();
let length = queue.length;
while(length--) {
let node = queue.shift();
// 把当前层节点存入curLevel数组
curLevel.push(node.val);
// 把下一层级的左右节点存入queue队列
node.left&&queue.push(node.left);
node.right&&queue.push(node.right);
node.left && queue.push(node.left);
node.right && queue.push(node.right);
}
// 从数组前头插入值，避免最后反转数组，减少运算时间
res.unshift(curLevel);
@ -852,21 +859,23 @@ javascript代码:
```javascript
var rightSideView = function(root) {
//二叉树右视图 只需要把每一层最后一个节点存储到res数组
let res=[],queue=[];
let res = [], queue = [];
queue.push(root);
while(queue.length&&root!==null){
while(queue.length && root!==null) {
// 记录当前层级节点个数
let length=queue.length;
while(length--){
let node=queue.shift();
//length长度为0的时候表明到了层级最后一个节点
if(!length){
let length = queue.length;
while(length--) {
let node = queue.shift();
// length长度为0的时候表明到了层级最后一个节点
if(!length) {
res.push(node.val);
}
node.left&&queue.push(node.left);
node.right&&queue.push(node.right);
node.left && queue.push(node.left);
node.right && queue.push(node.right);
}
}
return res;
};
```
@ -1129,22 +1138,24 @@ javascript代码：
```javascript
var averageOfLevels = function(root) {
//层级平均值
let res=[],queue=[];
let res = [], queue = [];
queue.push(root);
while(queue.length&&root!==null){
while(queue.length && root!==null) {
//每一层节点个数
let length=queue.length;
let length = queue.length;
//sum记录每一层的和
let sum=0;
for(let i=0;i<length;i++){
let node=queue.shift();
sum+=node.val;
node.left&&queue.push(node.left);
node.right&&queue.push(node.right);
let sum = 0;
for(let i=0; i < length; i++) {
let node = queue.shift();
sum += node.val;
node.left && queue.push(node.left);
node.right && queue.push(node.right);
}
//每一层的平均值存入数组res
res.push(sum/length);
}
return res;
};
```
@ -1405,24 +1416,25 @@ go:
*/
func levelOrder(root *Node) [][]int {
queue:=list.New()
res:=[][]int{}//结果集
if root==nil{
queue := list.New()
res := [][]int{} //结果集
if root == nil{
return res
}
queue.PushBack(root)
for queue.Len()>0{
length:=queue.Len()//记录当前层的数量
for queue.Len() > 0 {
length := queue.Len() //记录当前层的数量
var tmp []int
for T:=0;T<length;T++{//该层的每个元素：一添加到该层的结果集中；二找到该元素的下层元素加入到队列中，方便下次使用
myNode:=queue.Remove(queue.Front()).(*Node)
tmp=append(tmp,myNode.Val)
for i:=0;i<len(myNode.Children);i++{
for T := 0; T < length; T++ { //该层的每个元素：一添加到该层的结果集中；二找到该元素的下层元素加入到队列中，方便下次使用
myNode := queue.Remove(queue.Front()).(*Node)
tmp = append(tmp, myNode.Val)
for i := 0; i < len(myNode.Children); i++ {
queue.PushBack(myNode.Children[i])
}
}
res=append(res,tmp)
res = append(res, tmp)
}
return res
}
```
@ -1432,23 +1444,26 @@ JavaScript代码：
```JavaScript
var levelOrder = function(root) {
//每一层可能有2个以上,所以不再使用node.left node.right
let res=[],queue=[];
let res = [], queue = [];
queue.push(root);
while(queue.length&&root!==null){
while(queue.length && root!==null) {
//记录每一层节点个数还是和二叉树一致
let length=queue.length;
let length = queue.length;
//存放每层节点 也和二叉树一致
let curLevel=[];
while(length--){
let curLevel = [];
while(length--) {
let node = queue.shift();
curLevel.push(node.val);
//这里不再是 ndoe.left node.right 而是循坏node.children
for(let item of node.children){
item&&queue.push(item);
item && queue.push(item);
}
}
res.push(curLevel);
}
return res;
};
```
@ -1708,21 +1723,23 @@ javascript代码：
```javascript
var largestValues = function(root) {
//使用层序遍历
let res=[],queue=[];
let res = [], queue = [];
queue.push(root);
while(root!==null&&queue.length){
while(root !== null && queue.length) {
//设置max初始值就是队列的第一个元素
let max=queue[0].val;
let length=queue.length;
while(length--){
let max = queue[0].val;
let length = queue.length;
while(length--) {
let node = queue.shift();
max=max>node.val?max:node.val;
node.left&&queue.push(node.left);
node.right&&queue.push(node.right);
max = max > node.val ? max : node.val;
node.left && queue.push(node.left);
node.right && queue.push(node.right);
}
//把每一层的最大值放到res数组
res.push(max);
}
return res;
};
```
@ -1964,66 +1981,6 @@ class Solution:
first = first.left # 从本层扩展到下一层
return root
```
JavaScript:
```javascript
/**
* // Definition for a Node.
* function Node(val, left, right, next) {
* this.val = val === undefined ? null : val;
* this.left = left === undefined ? null : left;
* this.right = right === undefined ? null : right;
* this.next = next === undefined ? null : next;
* };
*/
/**
* @param {Node} root
* @return {Node}
*/
var connect = function(root) {
if (root === null) return root;
let queue = [root];
while (queue.length) {
let n = queue.length;
for (let i=0; i<n; i++) {
let node = queue.shift();
if (i < n-1) {
node.next = queue[0];
}
node.left && queue.push(node.left);
node.right && queue.push(node.right);
}
}
return root;
};
```
TypeScript:
```typescript
function connect(root: Node | null): Node | null {
let helperQueue: Node[] = [];
let preNode: Node, curNode: Node;
if (root !== null) helperQueue.push(root);
while (helperQueue.length > 0) {
for (let i = 0, length = helperQueue.length; i < length; i++) {
if (i === 0) {
preNode = helperQueue.shift()!;
} else {
curNode = helperQueue.shift()!;
preNode.next = curNode;
preNode = curNode;
}
if (preNode.left) helperQueue.push(preNode.left);
if (preNode.right) helperQueue.push(preNode.right);
}
preNode.next = null;
}
return root;
};
```
go:
```GO
@ -2064,6 +2021,66 @@ func connect(root *Node) *Node {
```
JavaScript:
```javascript
/**
* // Definition for a Node.
* function Node(val, left, right, next) {
* this.val = val === undefined ? null : val;
* this.left = left === undefined ? null : left;
* this.right = right === undefined ? null : right;
* this.next = next === undefined ? null : next;
* };
*/
/**
* @param {Node} root
* @return {Node}
*/
var connect = function(root) {
if (root === null) return root;
let queue = [root];
while (queue.length) {
let n = queue.length;
for (let i = 0; i < n; i++) {
let node = queue.shift();
if (i < n-1) {
node.next = queue[0];
}
node.left && queue.push(node.left);
node.right && queue.push(node.right);
}
}
return root;
};
```
TypeScript:
```typescript
function connect(root: Node | null): Node | null {
let helperQueue: Node[] = [];
let preNode: Node, curNode: Node;
if (root !== null) helperQueue.push(root);
while (helperQueue.length > 0) {
for (let i = 0, length = helperQueue.length; i < length; i++) {
if (i === 0) {
preNode = helperQueue.shift()!;
} else {
curNode = helperQueue.shift()!;
preNode.next = curNode;
preNode = curNode;
}
if (preNode.left) helperQueue.push(preNode.left);
if (preNode.right) helperQueue.push(preNode.right);
}
preNode.next = null;
}
return root;
};
```
Swift：
```swift
@ -2226,6 +2243,45 @@ class Solution:
return root
```
go:
```GO
/**
116. 填充每个节点的下一个右侧节点指针
117. 填充每个节点的下一个右侧节点指针 II
*/
func connect(root *Node) *Node {
if root == nil { //防止为空
return root
}
queue := list.New()
queue.PushBack(root)
tmpArr := make([]*Node, 0)
for queue.Len() > 0 {
length := queue.Len() //保存当前层的长度，然后处理当前层（十分重要，防止添加下层元素影响判断层中元素的个数）
for i := 0; i < length; i++ {
node := queue.Remove(queue.Front()).(*Node) //出队列
if node.Left != nil {
queue.PushBack(node.Left)
}
if node.Right != nil {
queue.PushBack(node.Right)
}
tmpArr = append(tmpArr, node) //将值加入本层切片中
}
if len(tmpArr) > 1 {
// 遍历每层元素,指定next
for i := 0; i < len(tmpArr)-1; i++ {
tmpArr[i].Next = tmpArr[i+1]
}
}
tmpArr = []*Node{} //清空层的数据
}
return root
}
```
JavaScript:
```javascript
/**
@ -2284,44 +2340,6 @@ function connect(root: Node | null): Node | null {
};
```
go:
```GO
/**
116. 填充每个节点的下一个右侧节点指针
117. 填充每个节点的下一个右侧节点指针 II
*/
func connect(root *Node) *Node {
if root == nil { //防止为空
return root
}
queue := list.New()
queue.PushBack(root)
tmpArr := make([]*Node, 0)
for queue.Len() > 0 {
length := queue.Len() //保存当前层的长度，然后处理当前层（十分重要，防止添加下层元素影响判断层中元素的个数）
for i := 0; i < length; i++ {
node := queue.Remove(queue.Front()).(*Node) //出队列
if node.Left != nil {
queue.PushBack(node.Left)
}
if node.Right != nil {
queue.PushBack(node.Right)
}
tmpArr = append(tmpArr, node) //将值加入本层切片中
}
if len(tmpArr) > 1 {
// 遍历每层元素,指定next
for i := 0; i < len(tmpArr)-1; i++ {
tmpArr[i].Next = tmpArr[i+1]
}
}
tmpArr = []*Node{} //清空层的数据
}
return root
}
```
Swift：
```swift
@ -2461,7 +2479,6 @@ class Solution {
}
```
Python：
```python 3
class Solution:
@ -2498,20 +2515,20 @@ Go：
* }
*/
func maxDepth(root *TreeNode) int {
ans:=0
if root==nil{
ans := 0
if root == nil {
return 0
}
queue:=list.New()
queue := list.New()
queue.PushBack(root)
for queue.Len()>0{
length:=queue.Len()
for i:=0;i<length;i++{
node:=queue.Remove(queue.Front()).(*TreeNode)
if node.Left!=nil{
for queue.Len() > 0 {
length := queue.Len()
for i := 0; i < length; i++ {
node := queue.Remove(queue.Front()).(*TreeNode)
if node.Left != nil {
queue.PushBack(node.Left)
}
if node.Right!=nil{
if node.Right != nil {
queue.PushBack(node.Right)
}
}
@ -2521,8 +2538,6 @@ func maxDepth(root *TreeNode) int {
}
```
JavaScript：
```javascript
/**
@ -2763,30 +2778,29 @@ Go：
* }
*/
func minDepth(root *TreeNode) int {
ans:=0
if root==nil{
ans := 0
if root == nil {
return 0
}
queue:=list.New()
queue := list.New()
queue.PushBack(root)
for queue.Len()>0{
length:=queue.Len()
for i:=0;i<length;i++{
node:=queue.Remove(queue.Front()).(*TreeNode)
if node.Left==nil&&node.Right==nil{//当前节点没有左右节点，则代表此层是最小层
return ans+1//返回当前层 ans代表是上一层
for queue.Len() > 0 {
length := queue.Len()
for i := 0; i < length; i++ {
node := queue.Remove(queue.Front()).(*TreeNode)
if node.Left == nil && node.Right == nil { //当前节点没有左右节点，则代表此层是最小层
return ans+1 //返回当前层 ans代表是上一层
}
if node.Left!=nil{
if node.Left != nil {
queue.PushBack(node.Left)
}
if node.Right!=nil{
if node.Right != nil {
queue.PushBack(node.Right)
}
}
ans++//记录层数
}
return ans+1
}
```