LeetCode51--根据二叉树创建字符串、合并二叉树

1.根据二叉树创建字符串

//你需要采用前序遍历的方式，将一个二叉树转换成一个由括号和整数组成的字符串。 
//
// 空节点则用一对空括号 "()" 表示。而且你需要省略所有不影响字符串与原始二叉树之间的一对一映射关系的空括号对。 
//
// 示例 1: 
//
// 
//输入: 二叉树: [1,2,3,4]
//       1
//     /   \
//    2     3
//   /    
//  4     
//
//输出: "1(2(4))(3)"
//
//解释: 原本将是“1(2(4)())(3())”，
//在你省略所有不必要的空括号对之后，
//它将是“1(2(4))(3)”。
// 
//
// 示例 2: 
//
// 
//输入: 二叉树: [1,2,3,null,4]
//       1
//     /   \
//    2     3
//     \  
//      4 
//
//输出: "1(2()(4))(3)"
//
//解释: 和第一个示例相似，
//除了我们不能省略第一个对括号来中断输入和输出之间的一对一映射关系。
// 
// Related Topics 树 字符串

同样是两种解法，一种是采用深度优先遍历，即递归，当根节点非空时，一共有三种情况，即左右儿子皆为空，那么就返回“”，第二就是左儿子非空，右儿子为空，那么返回就是将左儿子放进函数之后递归的结果 ，第三就是右儿子非空，那就将左节点先代入进行递归，因为之前已经写过当节点为空时的情况，所以左节点无论是啥情况都能处理，然后将右节点代入进行递归。

另一种解法是采用广度优先遍历，即迭代，这样的话，就稍微会复杂一些，具体可以看官方题解：

https://leetcode-cn.com/problems/construct-string-from-binary-tree/

public String tree2str(TreeNode t) {
		if(t==null){
			return "";
		}else if(t.left == null && t.right == null){
			return t.val+"";
		}else if(t.left != null && t.right == null){
			return t.val + "("+tree2str(t.left)+")";
		//这里包含了两种情况，一种是左儿子不为空，右儿子为空
		//还有一种就是左右儿子都不为空
		}else{
			return t.val+"("+tree2str(t.left)+")("+tree2str(t.right)+")";
		}
	}

public String tree2str(TreeNode t) {
		if(t == null){
			return "";
		}
		Stack<TreeNode> stack = new Stack<>();
		stack.push(t);
		HashSet<TreeNode> visited = new HashSet<>();
		StringBuilder s = new StringBuilder();
		while (!stack.isEmpty()) {
			t = stack.peek();
			if (visited.contains(t)) {
				stack.pop();
				s.append(")");
			} else {
				visited.add(t);
				s.append("(" + t.val);
				if (t.left == null && t.right != null)
					s.append("()");
				if (t.right != null)
					stack.push(t.right);
				//将左子节点放在栈顶
				if (t.left != null)
					stack.push(t.left);
			}
		}
		return s.substring(1, s.length() - 1);
	}

2.合并二叉树

//给定两个二叉树，想象当你将它们中的一个覆盖到另一个上时，两个二叉树的一些节点便会重叠。 
//
// 你需要将他们合并为一个新的二叉树。合并的规则是如果两个节点重叠，那么将他们的值相加作为节点合并后的新值，否则不为 NULL 的节点将直接作为新二叉树的节点
//。 
//
// 示例 1: 
//
// 
//输入: 
// Tree 1                     Tree 2                  
//          1                         2                             
//         / \                       / \                            
//        3   2                     1   3                        
//       /                           \   \                      
//      5                             4   7                  
//输出: 
//合并后的树:
//      3
//     / \
//    4   5
//   / \   \ 
//  5   4   7
// 
//
// 注意: 合并必须从两个树的根节点开始。 
// Related Topics 树

 这里依然是采用两种方法，即深度优先和广度优先，深度优先是递归，也是几种情况，即当某棵树的节点为空，另一颗树对应的该节点为非空时，那么就直接返回这个非空的节点。如果当两个节点都为非空时，那么合并之后的节点就为两数之和。

public TreeNode mergeTrees(TreeNode root1, TreeNode root2) {
    	//深度优先遍历
		if(root1 == null){
			return root2;
		}if(root2 == null){
			return root1;
		}
		TreeNode merge = new TreeNode(root1.val + root2.val);
		merge.left = mergeTrees(root1.left, root2.left);
		merge.right = mergeTrees(root1.right, root2.right);
		return merge;
	}

至于广度优先比前面那个题都复杂，在这里就不再多说了，看官方题解：

https://leetcode-cn.com/problems/merge-two-binary-trees/solution/he-bing-er-cha-shu-by-leetcode-solution/

public TreeNode mergeTrees(TreeNode root1, TreeNode root2) {
		if(root1==null){
			return root2;
		}if(root2==null){
			return root1;
		}
		TreeNode merged = new TreeNode(root1.val + root2.val);
		LinkedList<TreeNode> queue = new LinkedList<>();
		LinkedList<TreeNode> queue1 = new LinkedList<>();
		LinkedList<TreeNode> queue2 = new LinkedList<>();
		queue.push(merged);
		queue1.add(root1);
		queue2.add(root2);
		while (!queue1.isEmpty() && !queue2.isEmpty()) {
			TreeNode node = queue.poll(), node1 = queue1.poll(), node2 = queue2.poll();
			TreeNode left1 = node1.left, left2 = node2.left, right1 = node1.right, right2 = node2.right;
			if (left1 != null || left2 != null) {
				if (left1 != null && left2 != null) {
					TreeNode left = new TreeNode(left1.val + left2.val);
					node.left = left;
					queue.offer(left);
					queue1.offer(left1);
					queue2.offer(left2);
				} else if (left1 != null) {
					node.left = left1;
				} else if (left2 != null) {
					node.left = left2;
				}
			}
			if (right1 != null || right2 != null) {
				if (right1 != null && right2 != null) {
					TreeNode right = new TreeNode(right1.val + right2.val);
					node.right = right;
					queue.offer(right);
					queue1.offer(right1);
					queue2.offer(right2);
				} else if (right1 != null) {
					node.right = right1;
				} else {
					node.right = right2;
				}
			}
		}
        return merged;
	}