[Swift]LeetCode1110. 删点成林 | Delete Nodes And Return Forest

★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★
➤微信公众号：山青咏芝（shanqingyongzhi）
➤博客园地址：山青咏芝（https://www.cnblogs.com/strengthen/）
➤GitHub地址：https://github.com/strengthen/LeetCode
➤原文地址：https://www.cnblogs.com/strengthen/p/11112218.html 
➤如果链接不是山青咏芝的博客园地址，则可能是爬取作者的文章。
➤原文已修改更新！强烈建议点击原文地址阅读！支持作者！支持原创！
★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★

Given the root of a binary tree, each node in the tree has a distinct value.

After deleting all nodes with a value in to_delete, we are left with a forest (a disjoint union of trees).

Return the roots of the trees in the remaining forest.  You may return the result in any order. 

Example 1:

Input: root = [1,2,3,4,5,6,7], to_delete = [3,5]
Output: [[1,2,null,4],[6],[7]] 

Constraints:

• The number of nodes in the given tree is at most 1000.
• Each node has a distinct value between 1 and 1000.
• to_delete.length <= 1000
• to_delete contains distinct values between 1 and 1000.

---

给出二叉树的根节点 root，树上每个节点都有一个不同的值。

如果节点值在 to_delete 中出现，我们就把该节点从树上删去，最后得到一个森林（一些不相交的树构成的集合）。

返回森林中的每棵树。你可以按任意顺序组织答案。 

示例：

输入：root = [1,2,3,4,5,6,7], to_delete = [3,5]
输出：[[1,2,null,4],[6],[7]] 

提示：

• 树中的节点数最大为 1000。
• 每个节点都有一个介于 1 到 1000 之间的值，且各不相同。
• to_delete.length <= 1000
• to_delete 包含一些从 1 到 1000、各不相同的值。

---

56ms

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     public var val: Int
 *     public var left: TreeNode?
 *     public var right: TreeNode?
 *     public init(_ val: Int) {
 *         self.val = val
 *         self.left = nil
 *         self.right = nil
 *     }
 * }
 */
class Solution {
    var ans = [TreeNode?]()
    func delNodes(_ root: TreeNode?, _ to_delete: [Int]) -> [TreeNode?] {
        var root = root
        if root != nil {
            if !to_delete.contains(root!.val) { ans.append(root) }
            traverseDelNodes(&root, Set<Int>(to_delete))
        }
        return ans
    }

    func traverseDelNodes(_ root: inout TreeNode?, _ to_delete: Set<Int>) {
        if root == nil { return }
        if to_delete.contains(root!.val) {
            if root!.left != nil {
                if !to_delete.contains(root!.left!.val) { ans.append(root!.left) }
                traverseDelNodes(&root!.left, to_delete)
            }

            if root!.right != nil {
                if !to_delete.contains(root!.right!.val) { ans.append(root!.right) }
                traverseDelNodes(&root!.right, to_delete)
            }
            root = nil
            return
        }
        if root!.left != nil { traverseDelNodes(&root!.left, to_delete) }
        if root!.right != nil { traverseDelNodes(&root!.right, to_delete) }
    }
}

---

60ms

class Solution {
  var rootNodes = [TreeNode]()
  var toDeleteSet: Set<Int>!
  
  func delNodes(_ root: TreeNode?, _ to_delete: [Int]) -> [TreeNode?] {
    toDeleteSet = Set<Int>(to_delete)
    helper(parent: nil, isRight: true, needToAdd: true, node: root)
    return rootNodes
  }
  
  func helper(parent: TreeNode?, isRight: Bool, needToAdd: Bool, node: TreeNode?) {
    guard let n = node else { return }
    if toDeleteSet.contains(n.val) {
      if isRight {
        parent?.right = nil
      } else {
        parent?.left = nil
      }
      helper(parent: n, isRight: true, needToAdd: true, node: n.right)
      helper(parent: n, isRight: false, needToAdd: true, node: n.left)
    } else {
      if needToAdd {
        rootNodes.append(n)
      }
      helper(parent: n, isRight: true, needToAdd: false, node: n.right)
      helper(parent: n, isRight: false, needToAdd: false, node: n.left)
    }
  }
}

---

64ms

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     public var val: Int
 *     public var left: TreeNode?
 *     public var right: TreeNode?
 *     public init(_ val: Int) {
 *         self.val = val
 *         self.left = nil
 *         self.right = nil
 *     }
 * }
 */
class Solution {
    var ans = [TreeNode?]()
    func delNodes(_ root: TreeNode?, _ to_delete: [Int]) -> [TreeNode?] {
        var root = root
        if root != nil {
            if !to_delete.contains(root!.val) { ans.append(root) }
            traverseDelNodes(&root, Set<Int>(to_delete))
        }
        return ans
    }

    func traverseDelNodes(_ root: inout TreeNode?, _ to_delete: Set<Int>) {
        if root == nil { return }
        if to_delete.contains(root!.val) {
            var left = root!.left
            var right = root!.right
            root = nil
            if left != nil {
                if !to_delete.contains(left!.val) { ans.append(left) }
                traverseDelNodes(&left, to_delete)
            }

            if right != nil {
                if !to_delete.contains(right!.val) { ans.append(right) }
                traverseDelNodes(&right, to_delete)
            }
            return
        }
        if root!.left != nil { traverseDelNodes(&root!.left, to_delete) }
        if root!.right != nil { traverseDelNodes(&root!.right, to_delete) }
    }
}

---

Runtime: 72 ms

Memory Usage: 22.1 MB

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     public var val: Int
 *     public var left: TreeNode?
 *     public var right: TreeNode?
 *     public init(_ val: Int) {
 *         self.val = val
 *         self.left = nil
 *         self.right = nil
 *     }
 * }
 */
class Solution {
    var ans:[TreeNode?] = [TreeNode?]()
    var ds:Set<Int> = Set<Int>()
    
    func delNodes(_ root: TreeNode?, _ to_delete: [Int]) -> [TreeNode?] {
        for x in to_delete
        {
            ds.insert(x)
        }
        dfs(root,1)
        return ans
    }
    
    func dfs(_ v: TreeNode?, _ top:Int) -> TreeNode?
    {
        if v == nil
        {
            return v
        }
        if ds.contains(v!.val)
        {
            dfs(v!.left,1)
            dfs(v!.right,1)
            return nil
        }
        if top != 0
        {
            ans.append(v)
        }
        v?.left = dfs(v!.left,0)
        v?.right = dfs(v!.right,0)
        return v
    }
}

---

104ms

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     public var val: Int
 *     public var left: TreeNode?
 *     public var right: TreeNode?
 *     public init(_ val: Int) {
 *         self.val = val
 *         self.left = nil
 *         self.right = nil
 *     }
 * }
 */
class Solution {
    func delete(_ root: TreeNode, _ parent: TreeNode?, _ toDel: inout [Int], _ result: inout [TreeNode?]) {
        var nextParent: TreeNode? = root
        if let toDelIdx = toDel.firstIndex(of: root.val) {
            toDel.remove(at: toDelIdx)
            
            if let parentSteady = parent {
                if parentSteady.left === root {
                    parentSteady.left = nil
                }
                if parentSteady.right === root {
                    parentSteady.right = nil
                }
            }
            nextParent = nil
        } else if parent == nil {
            result.append(root)
        }
        
        if let nodeLeft = root.left {
            delete(nodeLeft, nextParent, &toDel, &result)
        }

        if let nodeRight = root.right {
            delete(nodeRight, nextParent, &toDel, &result)
        }
    }
    
    func delNodes(_ root: TreeNode?, _ to_delete: [Int]) -> [TreeNode?] {
        var result: [TreeNode?] = []      
        if let rootSteady = root {
            var toDel = to_delete
            delete(rootSteady, nil, &toDel, &result)
        }
        if result.isEmpty {
            result = [ nil ]
        }
        return result
    }
}

---

176ms

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     public var val: Int
 *     public var left: TreeNode?
 *     public var right: TreeNode?
 *     public init(_ val: Int) {
 *         self.val = val
 *         self.left = nil
 *         self.right = nil
 *     }
 * }
 */
class Solution {
    func delNodes(_ root: TreeNode?, _ to_delete: [Int]) -> [TreeNode?] {
        //traverse tree, when find node, add left/right child to the results.
        var results = [TreeNode?]()
        guard let root = root else {return results}
       
        var trees = [TreeNode]() 
        trees.append(root)
        while trees.count > 0 {
            var tree = trees.removeFirst()
            if to_delete.contains(tree.val) {
                //this is not valid tree, no need to add to list, leave it out
                if let left = tree.left {
                    trees.append(left)
                }
                if let right = tree.right {
                    trees.append(right)
                }
            } else {
                results.append(tree)
                dfs(tree, to_delete, &trees)
            }
        }
        
      
        return results
    }
    
    func dfs(_ node: TreeNode?, _ toDelete: [Int], _ trees: inout [TreeNode]) {
        guard let node = node else {return}
        
        if let left = node.left {
            if toDelete.contains(left.val) {
                trees.append(left)
                node.left = nil
            } else {
                dfs(node.left, toDelete, &trees)
            }
        }
        
         if let right = node.right {
            if toDelete.contains(right.val) {
                trees.append(right)
                node.right = nil
            } else {
                dfs(node.right, toDelete, &trees)
            }
        }
       
    }
}