Leetcode——翻转二叉树 / 合并二叉树 / 相同的树

最新推荐文章于 2024-11-04 12:20:00 发布

Yawn__

最新推荐文章于 2024-11-04 12:20:00 发布

阅读量98

点赞数

分类专栏： LeetCode 文章标签： leetcode 算法 java

本文链接：https://blog.csdn.net/ly0724ok/article/details/119040649

版权

LeetCode 专栏收录该内容

198 篇文章 9 订阅

订阅专栏

1. 翻转二叉树

在这里插入图片描述

（1）递归

前序，后序都行
中序不行，中序会翻转两次

后序：

/**
 * 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 invertTree(TreeNode root) {
        if(root == null)
            return null;
        TreeNode left = invertTree(root.left);
        TreeNode right = invertTree(root.right);
        root.left = right;
        root.right = left;
        return root;
    }
}

前序：

class Solution {
	public TreeNode invertTree(TreeNode root) {
        if (root == null) {
            return null;
        }

        TreeNode temp = root.left;
        root.left = root.right;
        root.right = temp;

        invertTree(root.left);
        invertTree(root.right);
        return root;
    }
}

（2）广度优先搜索

/**
 * 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 invertTree(TreeNode root) {
		if(root==null) {
			return null;
		}
		//将二叉树中的节点逐层放入队列中，再迭代处理队列中的元素
		LinkedList<TreeNode> queue = new LinkedList<TreeNode>();
		queue.add(root);
		while(!queue.isEmpty()) {
			//每次都从队列中拿一个节点，并交换这个节点的左右子树
			TreeNode tmp = queue.poll();
			TreeNode left = tmp.left;
			tmp.left = tmp.right;
			tmp.right = left;
			//如果当前节点的左子树不为空，则放入队列等待后续处理
			if(tmp.left!=null) {
				queue.add(tmp.left);
			}
			//如果当前节点的右子树不为空，则放入队列等待后续处理
			if(tmp.right!=null) {
				queue.add(tmp.right);
			}
			
		}
		//返回处理完的根节点
		return root;
	}
}

2. 合并二叉树

在这里插入图片描述

（1）递归

对两棵树(r1,r2)进行合并，主要分为4中情况：

r1 和 r2 对应节点都为空，则合并后的对应节点为空。
r1 对应节点为空，r2 对应节点不为空，则合并后的对应节点为 r2。
r1 对应节点不为空，r2 对应节点为空，则合并后的对应节点为 r1。
r1 和 r2 对应节点都不为空，则合并后的节点为 r2+r1。

总结下递归的条件：

终止条件：树 1 的节点为 null，或者树 2 的节点为 null
递归函数内：将两个树的节点相加后，再赋给树 1 的节点。再递归的执行两个树的左节点，递归执行两个树的右节点

class Solution {
	public TreeNode mergeTrees(TreeNode t1, TreeNode t2) {
		if(t1==null || t2==null) {
			return t1==null? t2 : t1;
		}
		return dfs(t1,t2);
	}
	
	TreeNode dfs(TreeNode r1, TreeNode r2) {
		// 如果 r1和r2中，只要有一个是null，函数就直接返回
		if(r1==null || r2==null) {
			return r1 == null ? r2 : r1;
		}
		//让r1的值 等于  r1和r2的值累加，再递归的计算两颗树的左节点、右节点
		r1.val += r2.val;
		r1.left = dfs(r1.left,r2.left);
		r1.right = dfs(r1.right,r2.right);
		return r1;
	}
}

或者：

class Solution {
    public TreeNode mergeTrees(TreeNode root1, TreeNode root2) {
        // r1,r2中任何一个的当前节点为空，则直接将另一棵树的对应节点作为合并后的节点。
        if (root1 == null) 
        	return root2;
        if (root2 == null) 
        	return root1;
        	
        // 当两个节点都不为空时，将两个节点的合并作为合并后的节点
        TreeNode newNode = new TreeNode(root1.val + root2.val);
        
        // 合并完当前节点后，再合并其左右节点。
        newNode.left = mergeTrees(root1.left, root2.left);
        newNode.right = mergeTrees(root1.right, root2.right);
        
        return newNode;
    }
}

（2）BFS

只要两颗树的左节点都不为 null，就把将他们放入队列中；同理只要两棵树的右节点都不为 null 了，也将他们放入队列中。
然后我们不断的从队列中取出节点，把他们相加。
如果出现树 1 的 left 节点为 null，树 2 的 left 不为 null，直接将树 2 的 left 赋给树 1 就可以了；同理如果树 1 的 right 节点为 null，树 2 的不为 null，将树 2 的 right 节点赋给树 1。

class Solution {
	public TreeNode mergeTrees(TreeNode t1, TreeNode t2) {
	//如果 t1和t2中，只要有一个是null，函数就直接返回
		if(t1==null || t2==null) {
			return t1==null? t2 : t1;
		}
		Deque<TreeNode> queue = new LinkedList<>();
		queue.add(t1);
		queue.add(t2);
		while(queue.size()>0) {
			TreeNode r1 = queue.remove();
			TreeNode r2 = queue.remove();
			r1.val += r2.val;
			//如果r1和r2的左子树都不为空，就放到队列中
			//如果r1的左子树为空，就把r2的左子树挂到r1的左子树上
			if(r1.left!=null && r2.left!=null){
				queue.add(r1.left);
				queue.add(r2.left);
			}
			else if(r1.left==null) {
				r1.left = r2.left;
			}
			//对于右子树也是一样的
			if(r1.right!=null && r2.right!=null) {
				queue.add(r1.right);
				queue.add(r2.right);
			}
			else if(r1.right==null) {
				r1.right = r2.right;
			}
		}
		return t1;
	}
}

3. 相同的树

在这里插入图片描述

（1）递归

特例处理，先比较两个根节点：
如果两节点都为空，返回true；
如果两节点一个为空一个不为空，返回false；
如果两节点值不相同，返回false
如果两个节点值相同，比较左子树和右子树是否相同，这就进入了递归

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public boolean isSameTree(TreeNode p, TreeNode q) {
        if(p == null && q == null){
            return true;
        }else if(p == null || q == null){
            return false;
        }else if(p.val == q.val){
            return isSameTree(p.left, q.left) && isSameTree(p.right, q.right);
        }
        return false;
}

（2）迭代

特例处理：如果两根节点都为空，返回true；如果两根节点一个为空一个不为空，返回false
用两个队列分别存储p树和q树的节点，只要两个队列都非空就进入循环
循环中，先弹出两个队列的节点，如果值不同，直接返回false
接下来比较俩节点的子节点情况，如果俩节点的左子节点和右子节点没有分别都存在或都不存在，返回false
存在的子节点们分别入队
循环结束后，只有当两个队列都为空时才会返回true

class Solution {
    public boolean isSameTree(TreeNode p, TreeNode q) {
        if(p == null && q == null){
            return true;
        }else if(p == null || q == null){
            return false;
        }
        Queue<TreeNode> queue1 = new LinkedList<>();
        Queue<TreeNode> queue2 = new LinkedList<>();
        queue1.offer(p);
        queue2.offer(q);
        while(!queue1.isEmpty() && !queue2.isEmpty()){
            TreeNode node1 = queue1.poll();
            TreeNode node2 = queue2.poll();
            if(node1.val != node2.val){
                return false;
            }
            if((node1.left != null) ^ (node2.left != null)){
                return false;
            }
            if((node1.right != null) ^ (node2.right != null)){
                return false;
            }
            if(node1.left != null){
                queue1.offer(node1.left);
            }
            if(node1.right != null){
                queue1.offer(node1.right);
            }
            if(node2.left != null){
                queue2.offer(node2.left);
            }
            if(node2.right != null){
                queue2.offer(node2.right);
            }
        }
        return queue1.isEmpty() && queue2.isEmpty();
    }
}