2021-11-24力扣 111,226,101

最新推荐文章于 2024-06-26 12:22:59 发布

原创最新推荐文章于 2024-06-26 12:22:59 发布 · 89 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#leetcode

力扣专栏收录该内容

64 篇文章

订阅专栏

这篇博客介绍了三种二叉树操作的算法实现：计算二叉树的最小深度，翻转二叉树，以及判断二叉树是否对称。通过层序遍历和递归法展示了详细的代码实现过程，对于理解和解决二叉树问题提供了实用的方法。

111. 二叉树的最小深度

/**
 * 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 int minDepth(TreeNode root) {
        int count = 0;
        if(root == null) return 0;
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        while(!queue.isEmpty()){
            int n = queue.size();
            TreeNode node;
            int flag = 0;
            while(n > 0){
                 node = queue.poll();
                if(node.left != null) queue.offer(node.left);
                if(node.right != null) queue.offer(node.right);
                n--;
                //当当前节点的左右孩子节点都为空时，说明到达了一个叶子节点
                if(node.left == null && node.right == null){
                    flag = 1;
                    break;
                }
            }
            count++;
            if(flag == 1) break;
        }
        return count;
    }
}

226. 翻转二叉树

方法一：层序遍历

/**
 * 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 root;
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        while(!queue.isEmpty()){
            int n = queue.size();
            while(n != 0){
                TreeNode node = queue.poll();
                //实现左右孩子节点的交换
                TreeNode temp = node.left;
                node.left = node.right;
                node.right = temp;
                if(node.left != null) queue.offer(node.left);
                if(node.right != null) queue.offer(node.right);
              //  swap(node.left,node.right);
                n--;
            }
        }
    return root;
    }
  
}

方法二：递归法

/**
 * 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) {
        //递归法解题中间理解错误的是，进行左右节点的交换时，不是单纯的只交换了两个节点，是分别以两个节点为根的子树
        
        //递归终止条件：当前节点为 null 时返回
        if(root == null) return null;
        TreeNode temp = root.right;
        root.right = root.left;
        root.left = temp;
        invertTree(root.left);
        invertTree(root.right);
        return root;
    }
}

101. 对称二叉树

方法一：

/**
 * 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 boolean isSymmetric(TreeNode root) {
        if(root == null) return true;
        if(root.left == null && root.right == null) return true;
      
        Queue<TreeNode> queue = new LinkedList<>();
        //想不到直接就将左右孩子节点入队比较
        queue.offer(root.left);
        queue.offer(root.right);
        while(queue.size() > 0){
            TreeNode t1 = queue.poll();
            TreeNode t2 = queue.poll();
            //此条件忘了加了，如果两个节点都为空就继续循环，两者有一个为空就返回false
            if(t1== null && t2 == null) continue;
          //  if(t1 == null&&t2 != null || t2 == null&&t1!=null){
              if(t1 == null || t2 == null){
                return false;
            }
            if(t1.val != t2.val){
                return false;
            }
            queue.offer(t1.left);
            queue.offer(t2.right);
            queue.offer(t1.right);
            queue.offer(t2.left);
        }
    return true;
    }
}

方法二：

class Solution {
	public boolean isSymmetric(TreeNode root) {
		if(root==null) {
			return true;
		}
		//调用递归函数，比较左节点，右节点
		return dfs(root.left,root.right);
	}
	
	boolean dfs(TreeNode left, TreeNode right) {
		//递归的终止条件是两个节点都为空
		//或者两个节点中有一个为空
		//或者两个节点的值不相等
		if(left==null && right==null) {
			return true;
		}
		if(left==null || right==null) {
			return false;
		}
		if(left.val!=right.val) {
			return false;
		}
		//再递归的比较 左节点的左孩子 和 右节点的右孩子
		//以及比较  左节点的右孩子 和 右节点的左孩子
		return dfs(left.left,right.right) && dfs(left.right,right.left);
	}
}