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

0102.二叉树的层序遍历：优化排版，补充Swift版本

Browse Source 
# Conflicts:
#	problems/0102.二叉树的层序遍历.md
This commit is contained in:
bqlin
2021-12-21 14:57:57 +08:00
committed by Bq
parent a9ae0f5d03
commit af54748675
1 changed files with 156 additions and 176 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@ -273,32 +273,29 @@ function levelOrder(root: TreeNode | null): number[][] {
}; };
``` ```
Swift: Swift：
```swift ```swift
func levelOrder(_ root: TreeNode?) -> [[Int]] { func levelOrder(_ root: TreeNode?) -> [[Int]] {
var res = [[Int]]() var result = [[Int]]()
guard let root = root else { guard let root = root else { return result }
return res // 表示一层
} var queue = [root]
var queue = [TreeNode]()
queue.append(root)
while !queue.isEmpty { while !queue.isEmpty {
let size = queue.count let count = queue.count
var sub = [Int]() var subarray = [Int]()
for _ in 0 ..< size { for _ in 0 ..< count {
// 当前层
let node = queue.removeFirst() let node = queue.removeFirst()
sub.append(node.val) subarray.append(node.val)
if let left = node.left { // 下一层
queue.append(left) if let node = node.left { queue.append(node) }
} if let node = node.right { queue.append(node) }
if let right = node.right {
queue.append(right)
}
} }
res.append(sub) result.append(subarray)
} }
return res
return result
} }
``` ```
@ -505,30 +502,29 @@ function levelOrderBottom(root: TreeNode | null): number[][] {
}; };
``` ```
Swift: Swift：
```swift ```swift
func levelOrderBottom(_ root: TreeNode?) -> [[Int]] { func levelOrderBottom(_ root: TreeNode?) -> [[Int]] {
var res = [[Int]]() // 表示一层
guard let root = root else { var queue = [TreeNode]()
return res if let node = root { queue.append(node) }
} var result = [[Int]]()
var queue: [TreeNode] = [root]
while !queue.isEmpty { while !queue.isEmpty {
var sub = [Int]() let count = queue.count
for _ in 0 ..< queue.count { var subarray = [Int]()
for _ in 0 ..< count {
// 当前层
let node = queue.removeFirst() let node = queue.removeFirst()
sub.append(node.val) subarray.append(node.val)
if let left = node.left { // 下一层
queue.append(left) if let node = node.left { queue.append(node) }
} if let node = node.right { queue.append(node)}
if let right = node.right {
queue.append(right)
}
} }
res.insert(sub, at: 0) result.append(subarray)
} }
return res
return result.reversed()
} }
``` ```
@ -729,37 +725,31 @@ function rightSideView(root: TreeNode | null): number[] {
}; };
``` ```
Swift: Swift：
```swift ```swift
func rightSideView(_ root: TreeNode?) -> [Int] { func rightSideView(_ root: TreeNode?) -> [Int] {
var res = [Int]() // 表示一层
guard let root = root else {
return res
}
var queue = [TreeNode]() var queue = [TreeNode]()
queue.append(root) if let node = root { queue.append(node) }
var result = [Int]()
while !queue.isEmpty { while !queue.isEmpty {
let size = queue.count let count = queue.count
for i in 0 ..< size { for i in 0 ..< count {
// 当前层
let node = queue.removeFirst() let node = queue.removeFirst()
if i == size - 1 { if i == count - 1 { result.append(node.val) }
// 保存 每层最后一个元素
res.append(node.val) // 下一层
} if let node = node.left { queue.append(node) }
if let left = node.left { if let node = node.right { queue.append(node) }
queue.append(left)
}
if let right = node.right {
queue.append(right)
}
} }
} }
return res
return result
} }
``` ```
# 637.二叉树的层平均值 # 637.二叉树的层平均值
[力扣题目链接](https://leetcode-cn.com/problems/average-of-levels-in-binary-tree/) [力扣题目链接](https://leetcode-cn.com/problems/average-of-levels-in-binary-tree/)
@ -965,32 +955,30 @@ function averageOfLevels(root: TreeNode | null): number[] {
}; };
``` ```
Swift: Swift：
```swift ```swift
func averageOfLevels(_ root: TreeNode?) -> [Double] { func averageOfLevels(_ root: TreeNode?) -> [Double] {
var res = [Double]() // 表示一层
guard let root = root else {
return res
}
var queue = [TreeNode]() var queue = [TreeNode]()
queue.append(root) if let node = root { queue.append(node) }
var result = [Double]()
while !queue.isEmpty { while !queue.isEmpty {
let size = queue.count let count = queue.count
var sum = 0 var sum = 0
for _ in 0 ..< size { for _ in 0 ..< count {
// 当前层
let node = queue.removeFirst() let node = queue.removeFirst()
sum += node.val sum += node.val
if let left = node.left {
queue.append(left) // 下一层
} if let node = node.left { queue.append(node) }
if let right = node.right { if let node = node.right { queue.append(node) }
queue.append(right)
}
} }
res.append(Double(sum) / Double(size)) result.append(Double(sum) / Double(count))
} }
return res
return result
} }
``` ```
@ -1212,29 +1200,28 @@ function levelOrder(root: Node | null): number[][] {
}; };
``` ```
Swift: Swift：
```swift ```swift
func levelOrder(_ root: Node?) -> [[Int]] { func levelOrder(_ root: Node?) -> [[Int]] {
var res = [[Int]]() // 表示一层
guard let root = root else {
return res
}
var queue = [Node]() var queue = [Node]()
queue.append(root) if let node = root { queue.append(node) }
var result = [[Int]]()
while !queue.isEmpty { while !queue.isEmpty {
let size = queue.count let count = queue.count
var sub = [Int]() var subarray = [Int]()
for _ in 0 ..< size { for _ in 0 ..< count {
// 当前层
let node = queue.removeFirst() let node = queue.removeFirst()
sub.append(node.val) subarray.append(node.val)
for childNode in node.children { // 下一层
queue.append(childNode) for node in node.children { queue.append(node) }
}
} }
res.append(sub) result.append(subarray)
} }
return res
return result
} }
``` ```
@ -1419,34 +1406,30 @@ function largestValues(root: TreeNode | null): number[] {
}; };
``` ```
Swift: Swift：
```swift ```swift
func largestValues(_ root: TreeNode?) -> [Int] { func largestValues(_ root: TreeNode?) -> [Int] {
var res = [Int]() // 表示一层
guard let root = root else {
return res
}
var queue = [TreeNode]() var queue = [TreeNode]()
queue.append(root) if let node = root { queue.append(node) }
var result = [Int]()
while !queue.isEmpty { while !queue.isEmpty {
let size = queue.count let count = queue.count
var max: Int = Int.min var max = queue[0].val
for _ in 0 ..< size { for _ in 0 ..< count {
// 当前层
let node = queue.removeFirst() let node = queue.removeFirst()
if node.val > max { if node.val > max { max = node.val }
max = node.val
} // 下一层
if let left = node.left { if let node = node.left { queue.append(node) }
queue.append(left) if let node = node.right { queue.append(node) }
}
if let right = node.right {
queue.append(right)
}
} }
res.append(max) result.append(max)
} }
return res
return result
} }
``` ```
@ -1456,7 +1439,7 @@ func largestValues(_ root: TreeNode?) -> [Int] {
给定一个完美二叉树，其所有叶子节点都在同一层，每个父节点都有两个子节点。二叉树定义如下： 给定一个完美二叉树，其所有叶子节点都在同一层，每个父节点都有两个子节点。二叉树定义如下：
``` ```cpp
struct Node { struct Node {
int val; int val;
Node *left; Node *left;
@ -1677,33 +1660,34 @@ func connect(root *Node) *Node {
} }
``` ```
Swift: Swift：
```swift ```swift
func connect(_ root: Node?) -> Node? { func connect(_ root: Node?) -> Node? {
guard let root = root else { // 表示一层
return nil
}
var queue = [Node]() var queue = [Node]()
queue.append(root) if let node = root { queue.append(node) }
while !queue.isEmpty { while !queue.isEmpty {
let size = queue.count let count = queue.count
var preNode: Node? var current, previous: Node!
for i in 0 ..< size { for i in 0 ..< count {
let node = queue.removeFirst() // 当前层
if i == 0 { if i == 0 {
preNode = node previous = queue.removeFirst()
current = previous
} else { } else {
preNode?.next = node current = queue.removeFirst()
preNode = node previous.next = current
} previous = current
if let left = node.left {
queue.append(left)
}
if let right = node.right {
queue.append(right)
} }
// 下一层
if let node = current.left { queue.append(node) }
if let node = current.right { queue.append(node) }
} }
previous.next = nil
} }
return root return root
} }
``` ```
@ -1927,34 +1911,34 @@ func connect(root *Node) *Node {
return root return root
} }
``` ```
Swift： Swift：
```swift ```swift
func connect(_ root: Node?) -> Node? { func connect(_ root: Node?) -> Node? {
guard let root = root else { // 表示一层
return nil
}
var queue = [Node]() var queue = [Node]()
queue.append(root) if let node = root { queue.append(node) }
while !queue.isEmpty { while !queue.isEmpty {
let size = queue.count let count = queue.count
var preNode: Node? var current, previous: Node!
for i in 0 ..< size { for i in 0 ..< count {
let node = queue.removeFirst() // 当前层
if i == 0 { if i == 0 {
preNode = node previous = queue.removeFirst()
current = previous
} else { } else {
preNode?.next = node current = queue.removeFirst()
preNode = node previous.next = current
} previous = current
if let left = node.left {
queue.append(left)
}
if let right = node.right {
queue.append(right)
} }
// 下一层
if let node = current.left { queue.append(node) }
if let node = current.right { queue.append(node) }
} }
previous.next = nil
} }
return root return root
} }
``` ```
@ -2151,29 +2135,28 @@ function maxDepth(root: TreeNode | null): number {
}; };
``` ```
Swift: Swift：
```swift ```swift
func maxDepth(_ root: TreeNode?) -> Int { func maxDepth(_ root: TreeNode?) -> Int {
guard let root = root else { guard root != nil else { return 0 }
return 0 var depth = 0
}
var queue = [TreeNode]() var queue = [TreeNode]()
queue.append(root) queue.append(root!)
var res: Int = 0
while !queue.isEmpty { while !queue.isEmpty {
for _ in 0 ..< queue.count { let count = queue.count
depth += 1
for _ in 0 ..< count {
// 当前层
let node = queue.removeFirst() let node = queue.removeFirst()
if let left = node.left {
queue.append(left) // 下一层
} if let node = node.left { queue.append(node) }
if let right = node.right { if let node = node.right { queue.append(node) }
queue.append(right)
}
} }
res += 1
} }
return res
return depth
} }
``` ```
@ -2374,28 +2357,25 @@ Swift：
```swift ```swift
func minDepth(_ root: TreeNode?) -> Int { func minDepth(_ root: TreeNode?) -> Int {
guard let root = root else { guard root != nil else { return 0 }
return 0 var depth = 0
} var queue = [root!]
var res = 0
var queue = [TreeNode]()
queue.append(root)
while !queue.isEmpty { while !queue.isEmpty {
res += 1 let count = queue.count
for _ in 0 ..< queue.count { depth += 1
for _ in 0 ..< count {
// 当前层
let node = queue.removeFirst() let node = queue.removeFirst()
if node.left == nil && node.right == nil { if node.left == nil, node.right == nil { // 遇到叶子结点则返回
return res return depth
}
if let left = node.left {
queue.append(left)
}
if let right = node.right {
queue.append(right)
} }
// 下一层
if let node = node.left { queue.append(node) }
if let node = node.right { queue.append(node) }
} }
} }
return res return depth
} }
``` ```