给定一个二叉树，根节点为第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
注意:
输入的深度值 d 的范围是：[1，二叉树最大深度 + 1]。
输入的二叉树至少有一个节点。
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/add-one-row-to-tree
一
这道题让我们给二叉树增加一行，给了需要增加的值，还有需要增加的位置深度，题目中给的例子也比较能清晰的说明问题。但是漏了一种情况，那就是当d=1时，这该怎么加？这时候就需要替换根结点了。其他情况的处理方法都一样，这里博主第一映像觉得应该用层序遍历来做，每遍历完一层，d自减1，当d==1时，需要对于当前层的每一个结点，先用临时变量保存其原有的左右子结点，然后新建值为v的左右子结点，将原有的左子结点连到新建的左子结点的左子结点上，将原有的右子结点连到新建的右子结点的右子结点，是不是很绕-.-|||。如果d不为1，那么就是层序遍历原有的排入队列操作，记得当检测到d为0时，直接返回，因为添加操作已经完成，没有必要遍历完剩下的结点，参见代码如下：
解法一：
class Solution {
public:
TreeNode* addOneRow(TreeNode* root, int v, int d) {
if (!root) return NULL;
if (d == 1) {
TreeNode *newRoot = new TreeNode(v);
newRoot->left = root;
return newRoot;
}
queue<TreeNode*> q{{root}};
while (!q.empty()) {
if (--d == 0) return root;
int n = q.size();
for (int i = 0; i < n; ++i) {
auto t = q.front(); q.pop();
if (d == 1) {
TreeNode *left = t->left;
TreeNode *right = t->right;
t->left = new TreeNode(v);
t->right = new TreeNode(v);
t->left->left = left;
t->right->right = right;
} else {
if (t->left) q.push(t->left);
if (t->right) q.push(t->right);
}
}
}
return root;
}
};
虽然博主一贯的理念是二叉树问题肯定首选递归来解，但是这道题博主刚开始以为递归没法解，结果看了大神们的帖子，才发现自己还是图样图森破，难道二叉树的问题皆可递归？反正这道题是可以的，而且写法 so 简洁，乍一看上去，会有疑问，题目中明明d的范围是从1开始的，为何要考虑d为0的情况，后来读懂了整个解法后，才为原作者的聪慧叹服。这里d的0和1，其实相当于一种 flag，如果d为1的话，那么将 root 连到新建的结点的左子结点上；反之如果d为0，那么将 root 连到新建的结点的右子结点上，然后返回新建的结点。如果 root 存在且d大于1的话，那么对 root 的左子结点调用递归函数，注意此时若d的值正好为2，那么就不能直接减1，而是根据左右子结点的情况分别赋值1和0，这样才能起到 flag 的作用嘛，叼的飞起，参见代码如下：
解法二：
class Solution {
public:
TreeNode* addOneRow(TreeNode* root, int v, int d) {
if (d == 0 || d == 1) {
TreeNode *newRoot = new TreeNode(v);
(d ? newRoot->left : newRoot->right) = root;
return newRoot;
}
if (root && 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;
}
};
二
方法一：深度优先搜索（递归）
如果 d 的值为 1，我们就添加一个节点，并将整棵树作为新节点的左子树。否则我们可以使用深度优先搜索找出所有 d 层的节点并进行操作。在搜索时，我们需要记录当前节点的深度 depth，如果此时 depth == d - 1，那么我们需要在当前节点的左右孩子各增加一个节点。如果当前节点的左右孩子已经有节点，我们就将这些节点存储到临时变量中，在增加新节点后再把左右孩子作为新节点的左子树或右子树，并结束递归。如果 depth != d - 1，我们就需要对当前节点的子节点进行递归搜索。
java
public class Solution {
public TreeNode addOneRow(TreeNode t, int v, int d) {
if (d == 1) {
TreeNode n = new TreeNode(v);
n.left = t;
return n;
}
insert(v, t, 1, d);
return t;
}
public void insert(int val, TreeNode node, int depth, int n) {
if (node == null)
return;
if (depth == n - 1) {
TreeNode t = node.left;
node.left = new TreeNode(val);
node.left.left = t;
t = node.right;
node.right = new TreeNode(val);
node.right.right = t;
} else {
insert(val, node.left, depth + 1, n);
insert(val, node.right, depth + 1, n);
}
}
}
复杂度分析
时间复杂度：O(N)，其中 N 是二叉树的节点个数。我们最多会遍历 N 个节点。
空间复杂度：O(N)。在最坏情况下，需要递归 N 层，用到 O(N) 的栈空间。
方法二：深度优先搜索（非递归）
我们可以直接用栈来模拟递归，实现深度优先搜索的非递归版本。
我们首先将根节点入栈，随后每次栈顶的元素即为当前搜索到的结点，我们取出这个节点，根据 depth 和 d - 1 的关系为当前节点增加新的子节点，或者将当前节点的子节点全部入栈，继续搜索。
java
public class Solution {
class Node{
Node(TreeNode n,int d){
node=n;
depth=d;
}
TreeNode node;
int depth;
}
public TreeNode addOneRow(TreeNode t, int v, int d) {
if (d == 1) {
TreeNode n = new TreeNode(v);
n.left = t;
return n;
}
Stack<Node> stack=new Stack<>();
stack.push(new Node(t,1));
while(!stack.isEmpty())
{
Node n=stack.pop();
if(n.node==null)
continue;
if (n.depth == d - 1 ) {
TreeNode temp = n.node.left;
n.node.left = new TreeNode(v);
n.node.left.left = temp;
temp = n.node.right;
n.node.right = new TreeNode(v);
n.node.right.right = temp;
} else{
stack.push(new Node(n.node.left, n.depth + 1));
stack.push(new Node(n.node.right, n.depth + 1));
}
}
return t;
}
}
复杂度分析
时间复杂度：O(N)，其中 N 是二叉树的节点个数。我们最多会遍历 N 个节点。
空间复杂度：O(N)。
方法三：广度优先搜索
我们同样可以使用广度优先搜索解决这个问题，并且广度优先搜索是最容易理解且最直观的一种方法。
我们将根节点放入队列 queue。在每一轮搜索中，如果 queue 中节点的深度为 d - 1（显然 queue 中所有的节点都在同一深度），我们就退出搜索，并为 queue 中所有节点添加新的子节点；否则我们将 queue 中所有节点的子节点放入新的队列 temp 中，再用 temp 替代 queue。
java
public class Solution {
public TreeNode addOneRow(TreeNode t, int v, int d) {
if (d == 1) {
TreeNode n = new TreeNode(v);
n.left = t;
return n;
}
Queue < TreeNode > queue = new LinkedList < > ();
queue.add(t);
int depth = 1;
while (depth < d - 1) {
Queue < TreeNode > temp = new LinkedList < > ();
while (!queue.isEmpty()) {
TreeNode node = queue.remove();
if (node.left != null) temp.add(node.left);
if (node.right != null) temp.add(node.right);
}
queue = temp;
depth++;
}
while (!queue.isEmpty()) {
TreeNode node = queue.remove();
TreeNode temp = node.left;
node.left = new TreeNode(v);
node.left.left = temp;
temp = node.right;
node.right = new TreeNode(v);
node.right.right = temp;
}
return t;
}
}
复杂度分析
时间复杂度：O(N)，其中 NN 是二叉树的节点个数。我们最多会遍历 N 个节点。
空间复杂度：O(N)。
三
按层递归遍历到目标层的前一层按规则直接改树，注意第一层是边界，需要单独输出。
python
class Solution:
def addOneRow(self, root: TreeNode, v: int, d: int) -> TreeNode:
if d == 1:
r = TreeNode(v)
r.left = root
return r
def f(r, i):
if r:
if i < d-1:
f(r.left, i + 1)
f(r.right, i + 1)
else:
t = TreeNode(v)
t.left = r.left
r.left = t
t = TreeNode(v)
t.right = r.right
r.right = t
f(root, 1)
return root