[Swift]LeetCode623. 在二叉树中增加一行 | Add One Row to Tree

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

Given the root of a binary tree, then value v and depth d, you need to add a row of nodes with value v at the given depth d. The root node is at depth 1.

The adding rule is: given a positive integer depth d, for each NOT null tree nodes N in depth d-1, create two tree nodes with value v as N's left subtree root and right subtree root. And N's original left subtree should be the left subtree of the new left subtree root, its original right subtree should be the right subtree of the new right subtree root. If depth d is 1 that means there is no depth d-1 at all, then create a tree node with value v as the new root of the whole original tree, and the original tree is the new root's left subtree.

Example 1:

Input: 
A binary tree as following:
       4
     /   
    2     6
   /    / 
  3   1 5   

v = 1

d = 2

Output: 
       4
      / 
     1   1
    /     
   2       6
  /      / 
 3   1   5    

Example 2:

Input: 
A binary tree as following:
      4
     /   
    2    
   /    
  3   1    

v = 1

d = 3

Output: 
      4
     /   
    2
   /     
  1   1
 /       
3       1 

Note:

1. The given d is in range [1, maximum depth of the given tree + 1].
2. The given binary tree has at least one tree node.

---

给定一个二叉树，根节点为第1层，深度为 1。在其第 d 层追加一行值为 v 的节点。

添加规则：给定一个深度值 d （正整数），针对深度为 d-1 层的每一非空节点 N，为 N 创建两个值为 v 的左子树和右子树。

将 N 原先的左子树，连接为新节点 v 的左子树；将 N 原先的右子树，连接为新节点 v 的右子树。

如果 d 的值为 1，深度 d - 1 不存在，则创建一个新的根节点 v，原先的整棵树将作为 v 的左子树。

示例 1:

输入: 
二叉树如下所示:
       4
     /   
    2     6
   /    / 
  3   1 5   

v = 1

d = 2

输出: 
       4
      / 
     1   1
    /     
   2       6
  /      / 
 3   1   5   

示例 2:

输入: 
二叉树如下所示:
      4
     /   
    2    
   /    
  3   1    

v = 1

d = 3

输出: 
      4
     /   
    2
   /     
  1   1
 /       
3       1

注意:

1. 输入的深度值 d 的范围是：[1，二叉树最大深度 + 1]。
2. 输入的二叉树至少有一个节点。

---

Runtime: 36 ms

Memory Usage: 20.6 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 {
    func addOneRow(_ root: TreeNode?, _ v: Int, _ d: Int) -> TreeNode? {
        if d == 0 || d == 1
        {
            var newRoot:TreeNode? = TreeNode(v)
            if d == 0
            {
                newRoot!.right = root
            }
            else
            {
                newRoot!.left = root
            }
            return newRoot
        }
        if root != nil && d > 1
        {
            root!.left = addOneRow(root!.left, v, d > 2 ? d - 1 : 1)
            root!.right = addOneRow(root!.right, v, d > 2 ? d - 1 : 0)
        }
        return root
    }
}

---

44ms

/**
 * 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 addOneRow(_ root: TreeNode?, _ v: Int, _ d: Int) -> TreeNode? {
        if d == 1 {
            let newRoot = TreeNode(v)
            newRoot.left = root
            return newRoot
        }
        helper(root, v, 1, d)
        return root
    }
    
    private func helper(_ root: TreeNode?, _ v: Int, _ d: Int, _ targetD: Int) {
        guard let root = root else { return }
        if d == targetD - 1 {
            let curLeft = root.left
            let curRight = root.right
            root.left = TreeNode(v)
            root.right = TreeNode(v)
            root.left?.left = curLeft
            root.right?.right = curRight
            return
        }
        helper(root.left, v, d + 1, targetD)
        helper(root.right, v, d + 1, targetD)
    }
}

---

48ms

class Solution {
    func addOneRow(_ root: TreeNode?, _ v: Int, _ d: Int) -> TreeNode? {
        if root == nil {
            return nil
        }
        
        var root = root
        if d == 1 {
            let newNode = TreeNode(v)
            newNode.left = root
            root = newNode
            
            return root
        }
        
        var nodes = [(root, 1)]
        while let (node, level) = nodes.popLast(), level < d {
            if let left = node?.left {
                nodes.insert((left, level + 1), at: 0)
            }
            if let right = node?.right {
                nodes.insert((right, level + 1), at: 0)
            }
            
            if level == d - 1 {
                let leftNode = TreeNode(v)
                leftNode.left = node?.left
                node?.left = leftNode
                
                let rightNode = TreeNode(v)
                rightNode.right = node?.right
                node?.right = rightNode
            }
            
            if level > d {
                break
            }
        }
        
        return root
    }
}

---

60ms

/**
 * 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 addOneRow(_ root: TreeNode?, _ v: Int, _ d: Int) -> TreeNode? {
        if d == 1 {
            var node = TreeNode(v)
            node.left = root
            return node
        }
        
        var stack = [TreeNode?]()
        var tempArr = [TreeNode?]()
        var currLevel = 1
        stack.append(root)
        while currLevel != d - 1 {
            //print("currLevel: (currLevel) ==============")
            while !stack.isEmpty {
                guard let node = stack.removeLast() else {
                    continue
                }
                //print("node: (node.val)")
                if let lNode = node.left {
                    tempArr.append(lNode)
                }
                if let rNode = node.right {
                    tempArr.append(rNode)
                }
            }
            stack.append(contentsOf: tempArr)
            tempArr.removeAll()
            currLevel += 1 
        }
        
        while !stack.isEmpty {
            guard let node = stack.removeLast() else {
                continue
            }
            //print("===== node: (node.val)")
            if let lNode = node.left { 
                var vNode = TreeNode(v)
                vNode.left = lNode
                node.left = vNode
            } else {
                var vNode = TreeNode(v)
                node.left = vNode
            }
            if let rNode = node.right { 
                var vNode = TreeNode(v)
                vNode.right = rNode
                node.right = vNode
            } else {
                var vNode = TreeNode(v)
                node.right = vNode
            }
        }
        return root
    }
}

---

76ms

/**
 * 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 addOneRow(_ root: TreeNode?, _ v: Int, _ d: Int) -> TreeNode? {
        if d == 1 {
            let node = TreeNode(v)
            node.left = root
            return node
        }

                
        if root == nil {
            return nil
        }
        
        let ans = root
        traverseAddOneRow(root!, v, d-1)
        return ans
    }

    func traverseAddOneRow(_ root: TreeNode?, _ v: Int, _ d: Int) {
        if root == nil {
            return
        }


        if d < 1 {
            return
        }

        if d == 1 {

            let lastl = root!.left
            let l = TreeNode(v)
            root!.left = l
            l.left = lastl

            let lastr = root!.right
            let r = TreeNode(v)
            root!.right = r
            r.right = lastr

            return
        }
        traverseAddOneRow(root!.left, v, d-1)
        traverseAddOneRow(root!.right, v, d-1)
    }

}