学习计划算法: 第八天

合并二叉树

给定两个二叉树，想象当你将它们中的一个覆盖到另一个上时，两个二叉树的一些节点便会重叠。

你需要将他们合并为一个新的二叉树。合并的规则是如果两个节点重叠，那么将他们的值相加作为节点合并后的新值，否则不为 NULL 的节点将直接作为新二叉树的节点。

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public TreeNode mergeTrees(TreeNode root1, TreeNode root2) {

        int realVal = 0;
        boolean b = false;
        boolean c = false;
        if(root1 != null){
            realVal += root1.val;
            b = true;
        }

        if(root2 != null){
            realVal += root2.val;
            c = true;
        }
        
        if(!b && !c){
            return null;
        }
        TreeNode node = new TreeNode();
        node.val = realVal;
        TreeNode l1 = null;
        TreeNode r1 = null;
        if(root1 != null){
            l1 = root1.left;
            r1 = root1.right;
        }
        TreeNode l2 = null;
         TreeNode r2 = null;
        if(root2 != null){
            l2 = root2.left;
            r2 = root2.right;
        }
        node.left = mergeTrees(l1,  l2);
        node.right = mergeTrees(r1,  r2);
        return node;
    }
}

填充每个节点的下一个右侧节点指针

给定一个 完美二叉树 ，其所有叶子节点都在同一层，每个父节点都有两个子节点。二叉树定义如下：

struct Node {
  int val;
  Node *left;
  Node *right;
  Node *next;
}

填充它的每个 next 指针，让这个指针指向其下一个右侧节点。如果找不到下一个右侧节点，则将 next 指针设置为 NULL。

初始状态下，所有 next 指针都被设置为 NULL。

进阶：

• 你只能使用常量级额外空间。
• 使用递归解题也符合要求，本题中递归程序占用的栈空间不算做额外的空间复杂度。

/*
// Definition for a Node.
class Node {
    public int val;
    public Node left;
    public Node right;
    public Node next;

    public Node() {}
    
    public Node(int _val) {
        val = _val;
    }

    public Node(int _val, Node _left, Node _right, Node _next) {
        val = _val;
        left = _left;
        right = _right;
        next = _next;
    }
};
*/

class Solution {
    public Node connect(Node root) {
          Node node = null;
        if (root != null) {
            node = root;
        }

        while (node != null) {
            Node nextPreNode = null;
            Node nextHeadNode = null;
            Node curNode = node;
            while (curNode != null) {
                if(curNode.left != null){
                    if(nextPreNode != null){
                        nextPreNode.next = curNode.left;
                    }
                    nextPreNode = curNode.left;
                    if(nextHeadNode == null){
                        nextHeadNode = curNode.left;
                    }
                }

                if(curNode.right != null){
                    if(nextPreNode != null){
                        nextPreNode.next = curNode.right;
                    }
                    nextPreNode = curNode.right;
                    if(nextHeadNode == null){
                        nextHeadNode = curNode.right;
                    }
                }
                curNode = curNode.next;
            }
            node = nextHeadNode;
        }
        return root;
    }
}