Merge pull request #1045 from YDLIN/master

添加257. 二叉树的所有路径 Swift 版本

problems/0112.路径总和.md

@@ -766,7 +766,124 @@ let pathSum = function(root, targetSum) {
 };
 ```
 
+## Swift
 
+0112.路径总和
+
+**递归**
+```swift
+func hasPathSum(_ root: TreeNode?, _ targetSum: Int) -> Bool {
+    guard let root = root else {
+        return false
+    }
+    
+    return traversal(root, targetSum - root.val)
+}
+
+func traversal(_ cur: TreeNode?, _ count: Int) -> Bool {
+    if cur?.left == nil && cur?.right == nil && count == 0 {
+        return true
+    }
+    
+    if cur?.left == nil && cur?.right == nil {
+        return false
+    }
+    
+    if let leftNode = cur?.left {
+        if traversal(leftNode, count - leftNode.val) {
+            return true
+        }
+    }
+    
+    if let rightNode = cur?.right {
+        if traversal(rightNode, count - rightNode.val) {
+            return true
+        }
+    }
+    
+    return false
+}
+```
+**迭代**
+```swift
+func hasPathSum(_ root: TreeNode?, _ targetSum: Int) -> Bool {
+    guard let root = root else {
+        return false
+    }
+    
+    var stack = Array<(TreeNode, Int)>()
+    stack.append((root, root.val))
+    
+    while !stack.isEmpty {
+        let node = stack.removeLast()
+        
+        if node.0.left == nil && node.0.right == nil && targetSum == node.1 {
+            return true
+        }
+        
+        if let rightNode = node.0.right {
+            stack.append((rightNode, node.1 + rightNode.val))
+        }
+        
+        if let leftNode = node.0.left {
+            stack.append((leftNode, node.1 + leftNode.val))
+        }
+    }
+    
+    return false
+}
+```
+
+0113.路径总和 II
+
+**递归**
+
+```swift
+var result = [[Int]]()
+var path = [Int]()
+func pathSum(_ root: TreeNode?, _ targetSum: Int) -> [[Int]] {
+    result.removeAll()
+    path.removeAll()
+    guard let root = root else {
+        return result
+    }
+    path.append(root.val)
+    traversal(root, count: targetSum - root.val)
+    return result
+
+}
+
+func traversal(_ cur: TreeNode?, count: Int) {
+    var count = count
+    // 遇到了叶子节点且找到了和为targetSum的路径
+    if cur?.left == nil && cur?.right == nil && count == 0 {
+        result.append(path)
+        return
+    }
+    
+    // 遇到叶子节点而没有找到合适的边，直接返回
+    if cur?.left == nil && cur?.right == nil{
+        return
+    }
+    
+    if let leftNode = cur?.left {
+        path.append(leftNode.val)
+        count -= leftNode.val
+        traversal(leftNode, count: count)// 递归
+        count += leftNode.val// 回溯
+        path.removeLast()// 回溯
+    }
+    
+    if let rightNode = cur?.right {
+        path.append(rightNode.val)
+        count -= rightNode.val
+        traversal(rightNode, count: count)// 递归
+        count += rightNode.val// 回溯
+        path.removeLast()// 回溯
+    }
+    return
+}
+```
 
 
 

problems/0257.二叉树的所有路径.md

@@ -582,7 +582,6 @@ var binaryTreePaths = function(root) {
 ```
 
 Swift:
-
 > 递归/回溯
 ```swift
 func binaryTreePaths(_ root: TreeNode?) -> [String] {

problems/0404.左叶子之和.md

@@ -373,6 +373,54 @@ var sumOfLeftLeaves = function(root) {
 ```
 
 
+## Swift 
+
+**递归法** 
+```swift
+func sumOfLeftLeaves(_ root: TreeNode?) -> Int {
+    guard let root = root else {
+        return 0
+    }
+
+    let leftValue = sumOfLeftLeaves(root.left)
+    let rightValue = sumOfLeftLeaves(root.right)
+
+    var midValue: Int = 0
+    if root.left != nil && root.left?.left == nil && root.left?.right == nil {
+        midValue = root.left!.val
+    }
+
+    let sum = midValue + leftValue + rightValue
+    return sum
+}
+```
+**迭代法**
+```swift
+func sumOfLeftLeaves(_ root: TreeNode?) -> Int {
+    guard let root = root else {
+        return 0
+    }
+
+    var stack = Array<TreeNode>()
+    stack.append(root)
+    var sum = 0
+
+    while !stack.isEmpty {
+        let lastNode = stack.removeLast()
+
+        if lastNode.left != nil && lastNode.left?.left == nil && lastNode.left?.right == nil {
+            sum += lastNode.left!.val
+        }
+        if let right = lastNode.right {
+            stack.append(right)
+        }
+        if let left = lastNode.left {
+            stack.append(left)
+        }
+    }
+    return sum
+}
+```
 
 
 

problems/0513.找树左下角的值.md

@@ -433,6 +433,74 @@ var findBottomLeftValue = function(root) {
 };
 ```
 
+## Swift 
+
+递归版本：
+
+```swift
+var maxLen = -1
+var maxLeftValue = 0
+func findBottomLeftValue_2(_ root: TreeNode?) -> Int {
+    traversal(root, 0)
+    return maxLeftValue
+}
+
+func traversal(_ root: TreeNode?, _ deep: Int) {
+    guard let root = root else {
+        return
+    }
+
+    if root.left == nil && root.right == nil {
+        if deep > maxLen {
+            maxLen = deep
+            maxLeftValue = root.val
+        }
+        return
+    }
+    
+    if root.left != nil {
+        traversal(root.left, deep + 1)
+    }
+    
+    if root.right != nil {
+        traversal(root.right, deep + 1)
+    }
+    return
+}
+```
+层序遍历：
+
+```swift
+func findBottomLeftValue(_ root: TreeNode?) -> Int {
+    guard let root = root else {
+        return 0
+    }
+    
+    var queue = [root]
+    var result = 0
+    
+    while !queue.isEmpty {
+        let size = queue.count
+        for i in 0..<size {
+            let firstNode = queue.removeFirst()
+          
+            if i == 0 {
+                result = firstNode.val
+            }
+            
+            if let leftNode = firstNode.left {
+                queue.append(leftNode)
+            }
+            
+            if let rightNode = firstNode.right {
+                queue.append(rightNode)
+            }
+        }
+    }
+    return result
+}
+```
+
 
 
 -----------------------

problems/0654.最大二叉树.md

@@ -401,6 +401,33 @@ struct TreeNode* constructMaximumBinaryTree(int* nums, int numsSize){
 }
 ```
 
+## Swift
+```swift
+func constructMaximumBinaryTree(_ nums: inout [Int]) -> TreeNode? {
+    return traversal(&nums, 0, nums.count)
+}
+
+func traversal(_ nums: inout [Int], _ left: Int, _ right: Int) -> TreeNode? {
+    if left >= right {
+        return nil
+    }
+    
+    var maxValueIndex = left
+    for i in (left + 1)..<right {
+        if nums[i] > nums[maxValueIndex] {
+            maxValueIndex = i
+        }
+    }
+    
+    let root = TreeNode(nums[maxValueIndex])
+    
+    root.left = traversal(&nums, left, maxValueIndex)
+    root.right = traversal(&nums, maxValueIndex + 1, right)
+    return root
+}
+```
+
+
 
 -----------------------
 <div align="center"><img src=https://code-thinking.cdn.bcebos.com/pics/01二维码一.jpg width=500> </img></div>