给定一个二叉树，根节点为第1层，深度为 1。在其第 d 层追加一行值为 v 的节点。
    添加规则：给定一个深度值 d （正整数），针对深度为 d-1 层的每一非空节点 N，为 N 创建两个值为 v 的左子树和右子树。
    将 N 原先的左子树，连接为新节点 v 的左子树；将 N 原先的右子树，连接为新节点 v 的右子树。
    如果 d 的值为 1，深度 d - 1 不存在，则创建一个新的根节点 v，原先的整棵树将作为 v 的左子树。
    示例 1:

    1. 输入: 
    2. 二叉树如下所示:
    3.        4
    4.      /   \
    5.     2     6
    6.    / \   / 
    7.   3   1 5   
    8. v = 1
    9. d = 2
    10. 输出: 
    11.        4
    12.       / \
    13.      1   1
    14.     /     \
    15.    2       6
    16.   / \     / 
    17.  3   1   5

    示例 2:

    输入: 
二叉树如下所示:
      4
     /   
    2    
   / \   
  3   1    
v = 1
d = 3
输出: 
      4
     /   
    2
   / \    
  1   1
 /     \  
3       1

    注意:

    1. 输入的深度值 d 的范围是：[1，二叉树最大深度 + 1]。

    2. 输入的二叉树至少有一个节点。

      /**
* Definition for a binary tree node.
* struct TreeNode {
*     int val;
*     TreeNode *left;
*     TreeNode *right;
*     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
* };
*/
class Solution {
public:
 TreeNode* addOneRow(TreeNode* root, int v, int d) {
     if(root == NULL){
         return NULL;
     }
     if(d == 1){
         cout<<" a"<<endl;
         TreeNode* lNode = new TreeNode(v);
         lNode->left = root;
         return lNode;
     }
     queue<TreeNode*> q;
     q.push(root);
     int level = 1;
     while(!q.empty() && level < d){
         int levelCurrentSize = q.size();

         for(int i =0;i<levelCurrentSize;i++){
             TreeNode* cur = q.front();
             if(level == d - 1){
                 cout<< cur->val<<" "<<endl;
                 TreeNode* left = cur->left;
                 TreeNode* right = cur->right;
                 TreeNode* lNode = new TreeNode(v);
                 TreeNode* rNode = new TreeNode(v);
                 cur->left = lNode;
                 cur->right = rNode;
                 cur->left->left = left;
                 cur->right->right = right;
                 q.pop();
             }else{
                 q.pop();
                 if(cur->left){
                     q.push(cur->left);
                 }
                 if(cur->right){
                     q.push(cur->right);
                 }
             }                
         }
         level++;
     }
     return root;
 }
};