Leetcode中二叉树性质相关的题目解析以及java实现

Leetcode中二叉树性质相关的题目解析以及java实现

• Maximum Depth of Binary Tree 二叉树的最大深度
• Minimum Depth of Binary Tree 二叉树的最小深度
• Maximum Width of Binary Tree：二叉树的最大宽度
• Same Tree：判断两棵二叉树是否相同
• Symmetric Tree：对称的二叉树（二叉树的镜像）
• Invert Binary Tree：翻转二叉树
• Subtree of Another Tree：判断二叉树是否为另一个树的子树

Maximum Depth of Binary Tree 二叉树的最大深度

这一题非常简单，就用分治法来解决就行了

class Solution {
    public int maxDepth(TreeNode root) {
        if(root == null){
            return 0;
        }
        return Math.max(1+maxDepth(root.left),1+maxDepth(root.right));
    }
}

Minimum Depth of Binary Tree 二叉树的最小深度

这一题和上一题基本上是一样的，稍微多了一点变化

class Solution {
    public int minDepth(TreeNode root) {
        if(root == null){
            return 0;
        }
        int left = minDepth(root.left);
        int right = minDepth(root.right);
        if(root.left == null){
            return right+1;
        }
        if(root.right == null){
            return left +1;
        }
        return Math.min(left,right)+1;
    }
}

Maximum Width of Binary Tree：二叉树的最大宽度

这一题就是要计算最大的宽度了，一般来说需要计算宽度的就是第一个想到BFS，然后我们利用两个队列来分别记录当前层级的节点和对应的下标，在遍历的过程中不将节点和相应下标添加进队列中，在bfs的过程中维护一个全局返回值来记录最大值。

class Solution{
	public int widthOfBinaryTree(TreeNode root){
		if(root == null) return 0;
		int result = 0;
		Queue<TreeNode> queue = new LinkedList<>();
		Queue<Integer> queuePos = new LinkedList<>();
		queue.offer(root);
		queuePos.offer(1);
		while(!queue.isEmpty()){
			int size = queue.size();
			int start = queuePos.peek();
			int end = start;
			for(int i = 0;i < size; i++){
				end = queuePos.poll();
				if(node.left != null){
					queue.offer(node.left);
					queuePos.offer(end*2);
				}
				if(node.right != null){
					queue.offer(node.right);
					queuePos.offer(end*2 +1);
				}
			}
			result = Math.max(result,end-start+1);
		}
		return result;
	}
}

Same Tree：判断两棵二叉树是否相同

非常简单的一道题，就是检查两棵二叉树是否相同，我们就递归分治法进行检查就是了

class Solution{
	public boolean isSameTree(TreeNode p, TreeNode q){
		if(p == null && q != null)return false;
		if(p != null && q == null) return false;
		if(p.val != q.val) return false;
		if(p == null && q == null) return true;
		boolean left = isSameTree(p.left,q.left);
		boolean right = isSameTree(p.right,q.right);
		return left&& right;
	}
}

Symmetric Tree：对称的二叉树（二叉树的镜像）

同样的我们只需要对每一个子节点的左右子树进行检查看是否相同即可，利用分治法递归实现就可以解决了

class Solution{
	public boolean isSymmetric(TreeNode root){
		if(root == null)return true;
		
	}
	protected boolean helper(TreeNode left, TreeNode right){
		if(left == null && right == null) return true;
		if(left == null && right != null) return false;
		if(left != null && right == null) return false;
		if(left.val != right.val) return false;
		boolean leftRes= helper(left.left,right.right);
		boolean rightRes= helper(left.right,right.left);
		return leftRes&& rightRes;
	}
}

Invert Binary Tree：翻转二叉树

也是很简单的一道题，将二叉树左右翻转，同样也是利用分治法递归实现

class Solution{
	public TreeNode invertTree(TreeNode root){
		if(root == null)return null;
		TreeNode temp = root.left;
		TreeNode left = root.right;
		root.right = temp;
		invertTree(root.right);
		invertTree(root.left);
		return root;	
	}
}

Subtree of Another Tree：判断二叉树是否为另一个树的子树

这一题同样也是利用，同样也是利用判断两棵树是否是相同的一样的方法，如果两棵二叉树一样则直接返回true，如果不一样递归检查左子节点和右子节点即可

class Solution {
    public boolean isSubtree(TreeNode s, TreeNode t) {
        if(s == null) return false;
        if(isSameTree(s,t))return true;
        return isSubtree(s.left,t) || isSubtree(s.right,t);
    }
    protected boolean isSameTree(TreeNode p, TreeNode q){
		if(p == null && q != null)return false;
		if(p != null && q == null) return false;
		if(p == null && q == null) return true;
        if(p.val != q.val) return false;
		boolean left = isSameTree(p.left,q.left);
		boolean right = isSameTree(p.right,q.right);
		return left&& right;
	}
}