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

Merge pull request #1109 from bqlin/master

Browse Source 
优化排版与 Swift 实现
This commit is contained in:
程序员Carl
2022-03-13 10:44:05 +08:00
committed by GitHub
parent d519c591ef 53d4999ad8
commit ab1364aebf
4 changed files with 258 additions and 247 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
} }
``` ```

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

@ -47,8 +47,6 @@
## 递归法 ## 递归法
对于二叉树的递归法的前中后序遍历，已经在[二叉树：前中后序递归遍历](https://programmercarl.com/二叉树的递归遍历.html)详细讲解了。 对于二叉树的递归法的前中后序遍历，已经在[二叉树：前中后序递归遍历](https://programmercarl.com/二叉树的递归遍历.html)详细讲解了。
我们下文以前序遍历为例，通过动画来看一下翻转的过程: 我们下文以前序遍历为例，通过动画来看一下翻转的过程:
@ -63,7 +61,7 @@
返回值的话其实也不需要，但是题目中给出的要返回root节点的指针，可以直接使用题目定义好的函数，所以就函数的返回类型为`TreeNode*`。 返回值的话其实也不需要，但是题目中给出的要返回root节点的指针，可以直接使用题目定义好的函数，所以就函数的返回类型为`TreeNode*`。
``` ```cpp
TreeNode* invertTree(TreeNode* root) TreeNode* invertTree(TreeNode* root)
``` ```
@ -71,7 +69,7 @@ TreeNode* invertTree(TreeNode* root)
当前节点为空的时候，就返回 当前节点为空的时候，就返回
``` ```cpp
if (root == NULL) return root; if (root == NULL) return root;
``` ```
@ -79,7 +77,7 @@ if (root == NULL) return root;
因为是先前序遍历，所以先进行交换左右孩子节点，然后反转左子树，反转右子树。 因为是先前序遍历，所以先进行交换左右孩子节点，然后反转左子树，反转右子树。
``` ```cpp
swap(root->left, root->right); swap(root->left, root->right);
invertTree(root->left); invertTree(root->left);
invertTree(root->right); invertTree(root->right);
@ -257,7 +255,7 @@ public:
## 其他语言版本 ## 其他语言版本
### Java： ### Java
```Java ```Java
//DFS递归 //DFS递归
@ -469,8 +467,6 @@ func invertTree(root *TreeNode) *TreeNode {
} }
``` ```
### JavaScript ### JavaScript
使用递归版本的前序遍历 使用递归版本的前序遍历
@ -690,7 +686,7 @@ function invertTree(root: TreeNode | null): TreeNode | null {
}; };
``` ```
### C: ### C
递归法 递归法
```c ```c
@ -775,5 +771,54 @@ func invertTree1(_ root: TreeNode?) -> TreeNode? {
} }
``` ```
### Swift
深度优先递归。
```swift
func invertTree(_ root: TreeNode?) -> TreeNode? {
guard let node = root else { return root }
swap(&node.left, &node.right)
_ = invertTree(node.left)
_ = invertTree(node.right)
return root
}
```
深度优先迭代，子结点顺序不重要，从根结点出发深度遍历即可。
```swift
func invertTree(_ root: TreeNode?) -> TreeNode? {
guard let node = root else { return root }
var stack = [node]
while !stack.isEmpty {
guard let node = stack.popLast() else { break }
swap(&node.left, &node.right)
if let node = node.left { stack.append(node) }
if let node = node.right { stack.append(node) }
}
return root
}
```
广度优先迭代。
```swift
func invertTree(_ root: TreeNode?) -> TreeNode? {
guard let node = root else { return root }
var queue = [node]
while !queue.isEmpty {
let count = queue.count
for _ in 0 ..< count {
let node = queue.removeFirst()
swap(&node.left, &node.right)
if let node = node.left { queue.append(node) }
if let node = node.right { queue.append(node) }
}
}
return root
}
```
----------------------- -----------------------
<div align="center"><img src=https://code-thinking.cdn.bcebos.com/pics/01二维码一.jpg width=500> </img></div> <div align="center"><img src=https://code-thinking.cdn.bcebos.com/pics/01二维码一.jpg width=500> </img></div>

104
problems/二叉树的迭代遍历.md
View File

@ -390,7 +390,7 @@ func inorderTraversal(root *TreeNode) []int {
} }
``` ```
javaScript javaScript：
```js ```js
@ -454,7 +454,7 @@ var postorderTraversal = function(root, res = []) {
}; };
``` ```
TypeScript: TypeScript：
```typescript ```typescript
// 前序遍历（迭代法） // 前序遍历（迭代法）
@ -509,77 +509,63 @@ function postorderTraversal(root: TreeNode | null): number[] {
}; };
``` ```
Swift: Swift：
> 迭代法前序遍历
```swift ```swift
// 前序遍历迭代法
func preorderTraversal(_ root: TreeNode?) -> [Int] { func preorderTraversal(_ root: TreeNode?) -> [Int] {
var res = [Int]() var result = [Int]()
if root == nil { guard let root = root else { return result }
return res var stack = [root]
}
var stack = [TreeNode]()
stack.append(root!)
while !stack.isEmpty { while !stack.isEmpty {
let node = stack.popLast()! let current = stack.removeLast()
res.append(node.val) // 先右后左，这样出栈的时候才是左右顺序
if node.right != nil { if let node = current.right { // 右
stack.append(node.right!) stack.append(node)
} }
if node.left != nil { if let node = current.left { // 左
stack.append(node.left!) stack.append(node)
} }
result.append(current.val) // 中
} }
return res return result
} }
```
> 迭代法中序遍历 // 后序遍历迭代法
```swift
func inorderTraversal(_ root: TreeNode?) -> [Int] {
var res = [Int]()
if root == nil {
return res
}
var stack = [TreeNode]()
var cur: TreeNode? = root
while cur != nil || !stack.isEmpty {
if cur != nil {
stack.append(cur!)
cur = cur!.left
} else {
cur = stack.popLast()
res.append(cur!.val)
cur = cur!.right
}
}
return res
}
```
> 迭代法后序遍历
```swift
func postorderTraversal(_ root: TreeNode?) -> [Int] { func postorderTraversal(_ root: TreeNode?) -> [Int] {
var res = [Int]() var result = [Int]()
if root == nil { guard let root = root else { return result }
return res var stack = [root]
}
var stack = [TreeNode]()
stack.append(root!)
// res 存储 中 -> 右 -> 左
while !stack.isEmpty { while !stack.isEmpty {
let node = stack.popLast()! let current = stack.removeLast()
res.append(node.val) // 与前序相反，即中右左，最后结果还需反转才是后序
if node.left != nil { if let node = current.left { // 左
stack.append(node.left!) stack.append(node)
} }
if node.right != nil { if let node = current.right { // 右
stack.append(node.right!) stack.append(node)
}
result.append(current.val) // 中
}
return result.reversed()
}
// 中序遍历迭代法
func inorderTraversal(_ root: TreeNode?) -> [Int] {
var result = [Int]()
var stack = [TreeNode]()
var current: TreeNode! = root
while current != nil || !stack.isEmpty {
if current != nil { // 先访问到最左叶子
stack.append(current)
current = current.left // 左
} else {
current = stack.removeLast()
result.append(current.val) // 中
current = current.right // 右
} }
} }
// res 翻转 return result
res.reverse()
return res
} }
``` ```

6
problems/二叉树的递归遍历.md
View File

@ -34,19 +34,19 @@
1. **确定递归函数的参数和返回值**：因为要打印出前序遍历节点的数值，所以参数里需要传入vector在放节点的数值，除了这一点就不需要在处理什么数据了也不需要有返回值，所以递归函数返回类型就是void，代码如下： 1. **确定递归函数的参数和返回值**：因为要打印出前序遍历节点的数值，所以参数里需要传入vector在放节点的数值，除了这一点就不需要在处理什么数据了也不需要有返回值，所以递归函数返回类型就是void，代码如下：
``` ```cpp
void traversal(TreeNode* cur, vector<int>& vec) void traversal(TreeNode* cur, vector<int>& vec)
``` ```
2. **确定终止条件**：在递归的过程中，如何算是递归结束了呢，当然是当前遍历的节点是空了，那么本层递归就要要结束了，所以如果当前遍历的这个节点是空，就直接return，代码如下： 2. **确定终止条件**：在递归的过程中，如何算是递归结束了呢，当然是当前遍历的节点是空了，那么本层递归就要要结束了，所以如果当前遍历的这个节点是空，就直接return，代码如下：
``` ```cpp
if (cur == NULL) return; if (cur == NULL) return;
``` ```
3. **确定单层递归的逻辑**：前序遍历是中左右的循序，所以在单层递归的逻辑，是要先取中节点的数值，代码如下： 3. **确定单层递归的逻辑**：前序遍历是中左右的循序，所以在单层递归的逻辑，是要先取中节点的数值，代码如下：
``` ```cpp
vec.push_back(cur->val); // 中 vec.push_back(cur->val); // 中
traversal(cur->left, vec); // 左 traversal(cur->left, vec); // 左
traversal(cur->right, vec); // 右 traversal(cur->right, vec); // 右