Leetcod刷题(12)——617.合并两颗二叉树

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

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

示例 1:

输入: 
	Tree 1                     Tree 2                  
          1                         2                             
         / \                       / \                            
        3   2                     1   3                        
       /                           \   \                      
      5                             4   7                  
输出: 
合并后的树:
	     3
	    / \
	   4   5
	  / \   \ 
	 5   4   7

注意: 合并必须从两个树的根节点开始。

思路:刚开始的想法是将t2合并到t1上,但是这样会带来很多的非空判断,所以改为直接新建一颗树,然后将2棵树合并的结果放入新树即可

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public TreeNode mergeTrees(TreeNode t1, TreeNode t2) {
        if(t1==null){
            return t2;
        }
        if(t2==null){
            return t1;
        }
        TreeNode node = new TreeNode(t1.val+t2.val);
         node.left= mergeTrees(t1.left,t2.left);
        node.right=mergeTrees(t1.right,t2.right);
        return node;
    }
}
好的,我会尽力回答你的问题。以下是对你提出的Java二叉树问题的回答: 1. 输入叶子点 首先,我们需要定义点类: ```java class Node { int value; Node left; Node right; public Node(int value) { this.value = value; } } ``` 然后,我们可以通过递归的方式生成二叉树: ```java public Node createTree(Scanner scanner) { System.out.println("请输入点值:"); int value = scanner.nextInt(); if (value == 0) { return null; } Node node = new Node(value); node.left = createTree(scanner); node.right = createTree(scanner); return node; } ``` 2. 求二叉树叶子结点个数 我们可以通过递归的方式遍历二叉树,统计叶子点的个数: ```java public int countLeafNodes(Node node) { if (node == null) { return 0; } if (node.left == null && node.right == null) { return 1; } return countLeafNodes(node.left) + countLeafNodes(node.right); } ``` 3. 将每个结点的左子树与右子树交换 我们可以通过递归的方式遍历二叉树,交换每个点的左右子树: ```java public void swapLeftRight(Node node) { if (node == null) { return; } Node temp = node.left; node.left = node.right; node.right = temp; swapLeftRight(node.left); swapLeftRight(node.right); } ``` 4. 验证二叉树的性质3:n0=n2+1 我们可以通过递归的方式遍历二叉树,统计叶子点和度为2的点的个数,然后判断它们是否符合性质3: ```java public boolean verifyPropertyThree(Node node) { int leafNodes = countLeafNodes(node); int degreeTwoNodes = countDegreeTwoNodes(node); return leafNodes == degreeTwoNodes + 1; } public int countDegreeTwoNodes(Node node) { if (node == null) { return 0; } if (node.left != null && node.right != null) { return countDegreeTwoNodes(node.left) + countDegreeTwoNodes(node.right) + 1; } return countDegreeTwoNodes(node.left) + countDegreeTwoNodes(node.right); } ``` 5. 输出值大于k的结点 我们可以通过递归的方式遍历二叉树,输出值大于k的点: ```java public void printNodesGreaterThanK(Node node, int k) { if (node == null) { return; } if (node.value > k) { System.out.print(node.value + " "); } printNodesGreaterThanK(node.left, k); printNodesGreaterThanK(node.right, k); } ``` 6. 已知先根和根次序遍历序列构造二叉树 我们可以通过递归的方式构造二叉树,先根次序遍历的第一个点是根点,然后在根次序遍历找到根点的位置,将序列分为左右两部分,分别构造左右子树: ```java public Node buildTree(int[] preOrder, int[] inOrder, int preStart, int preEnd, int inStart, int inEnd) { if (preStart > preEnd || inStart > inEnd) { return null; } int rootValue = preOrder[preStart]; Node root = new Node(rootValue); int rootIndex = -1; for (int i = inStart; i <= inEnd; i++) { if (inOrder[i] == rootValue) { rootIndex = i; break; } } int leftSize = rootIndex - inStart; root.left = buildTree(preOrder, inOrder, preStart + 1, preStart + leftSize, inStart, rootIndex - 1); root.right = buildTree(preOrder, inOrder, preStart + leftSize + 1, preEnd, rootIndex + 1, inEnd); return root; } ``` 7. 以广义表表示构造二叉树 我们可以通过递归的方式构造二叉树,广义表的表示方法是:(root,left,right),其left和right都是广义表的形式: ```java public Node buildTree(String str) { if (str == null || str.length() == 0) { return null; } int firstCommaIndex = str.indexOf(","); int value = Integer.parseInt(str.substring(1, firstCommaIndex)); Node root = new Node(value); int secondCommaIndex = findSecondCommaIndex(str); root.left = buildTree(str.substring(firstCommaIndex + 1, secondCommaIndex)); root.right = buildTree(str.substring(secondCommaIndex + 1, str.length() - 1)); return root; } private int findSecondCommaIndex(String str) { int count = 0; for (int i = 1; i < str.length() - 1; i++) { if (str.charAt(i) == '(') { count++; } else if (str.charAt(i) == ')') { count--; } else if (str.charAt(i) == ',' && count == 0) { return i; } } return -1; } ``` 8. 判断两颗二叉树是否相等 我们可以通过递归的方式比较两棵二叉树是否相等: ```java public boolean isSameTree(Node p, Node q) { if (p == null && q == null) { return true; } if (p == null || q == null) { return false; } if (p.value != q.value) { return false; } return isSameTree(p.left, q.left) && isSameTree(p.right, q.right); } ``` 9. 求结点所在的层次 我们可以通过递归的方式求出结点所在的层次: ```java public int getNodeLevel(Node node, Node target, int level) { if (node == null) { return 0; } if (node == target) { return level; } int leftLevel = getNodeLevel(node.left, target, level + 1); if (leftLevel != 0) { return leftLevel; } int rightLevel = getNodeLevel(node.right, target, level + 1); return rightLevel; } ``` 10. 求一颗二叉树在后根次序遍历下第一个访问的结点 我们可以通过递归的方式求出在后根次序遍历下第一个访问的结点: ```java public Node getFirstVisitNode(Node node) { if (node == null) { return null; } Node left = getFirstVisitNode(node.left); Node right = getFirstVisitNode(node.right); if (left == null && right == null) { return node; } if (right == null) { return left; } if (left == null) { return right; } return node; } ``` 11. 复制一颗二叉树 我们可以通过递归的方式复制一颗二叉树: ```java public Node cloneTree(Node node) { if (node == null) { return null; } Node clone = new Node(node.value); clone.left = cloneTree(node.left); clone.right = cloneTree(node.right); return clone; } ``` 12. 判断一颗二叉树是否为完全二叉树 我们可以通过层次遍历的方式判断一颗二叉树是否为完全二叉树: ```java public boolean isCompleteTree(Node node) { Queue<Node> queue = new LinkedList<>(); queue.offer(node); boolean nullNodeAppeared = false; while (!queue.isEmpty()) { Node current = queue.poll(); if (current == null) { nullNodeAppeared = true; } else { if (nullNodeAppeared) { return false; } queue.offer(current.left); queue.offer(current.right); } } return true; } ``` 13. 实现二叉树后根次序遍历的非递归算法的操作,并每一个操作分别采用先根、根、后根、层次遍历算法 我们可以使用栈的方式实现后根次序遍历的非递归算法,先根、根、层次遍历的非递归算法也可以使用栈或队列实现: ```java // 后根次序遍历的非递归算法 public void postOrderTraversal(Node node) { Stack<Node> stack1 = new Stack<>(); Stack<Node> stack2 = new Stack<>(); stack1.push(node); while (!stack1.isEmpty()) { Node current = stack1.pop(); stack2.push(current); if (current.left != null) { stack1.push(current.left); } if (current.right != null) { stack1.push(current.right); } } while (!stack2.isEmpty()) { System.out.print(stack2.pop().value + " "); } } // 先根次序遍历的非递归算法 public void preOrderTraversal(Node node) { Stack<Node> stack = new Stack<>(); stack.push(node); while (!stack.isEmpty()) { Node current = stack.pop(); System.out.print(current.value + " "); if (current.right != null) { stack.push(current.right); } if (current.left != null) { stack.push(current.left); } } } // 根次序遍历的非递归算法 public void inOrderTraversal(Node node) { Stack<Node> stack = new Stack<>(); Node current = node; while (current != null || !stack.isEmpty()) { while (current != null) { stack.push(current); current = current.left; } current = stack.pop(); System.out.print(current.value + " "); current = current.right; } } // 层次遍历的非递归算法 public void levelOrderTraversal(Node node) { Queue<Node> queue = new LinkedList<>(); queue.offer(node); while (!queue.isEmpty()) { Node current = queue.poll(); System.out.print(current.value + " "); if (current.left != null) { queue.offer(current.left); } if (current.right != null) { queue.offer(current.right); } } } ```
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

进击的代码家

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值