文章目录

🌏引言
🍀[相同的树](https://leetcode.cn/problems/same-tree/description/)
- 🐱‍🐉题目描述：
- 🐱‍👓示例：
- - 📌示例一
  - 📌示例二
  - 📌示例三
- 🐱‍👤题目解析
- - 🚩代码实现：
🌳[另一棵树的子树](https://leetcode.cn/problems/subtree-of-another-tree/description/)
- 🐱‍👤题目描述：
- 🐱‍🐉示例：
- - 📌示例一
  - 📌示例二
- 🐱‍👓解法思路：
- 🐱‍🐉代码实现
🎍[翻转二叉树](https://leetcode.cn/problems/invert-binary-tree/)
- 🐱‍👤题目描述：
- 🐱‍👓示例：
- 🐱‍🐉思路解析：
- 🐱‍🏍代码实现
🎄[平衡二叉树](https://leetcode.cn/problems/balanced-binary-tree/description/)
- 🐱‍👤题目描述
- 🐱‍🐉示例：
- - 📌示例一
  - 📌示例二
  - 📌示例三
- 🐱‍👓思路解析：
- - 🎈思路一
  - 🎈思路二
- 🐱‍🏍代码实现
- - 🚩思路一实现：
  - 🚩思路二实现：
🌲[对称二叉树](https://leetcode.cn/problems/symmetric-tree/description/)
- 🐱‍👤题目描述
- 🐱‍👓示例：
- - 📌示例一
  - 📌示例二
- 🐱‍🐉思路解析
- 🐱‍🏍代码实现：
🎡[二叉树的层序遍历](https://leetcode.cn/problems/binary-tree-level-order-traversal/)
- 🐱‍👤题目描述：
- 🐱‍🐉示例：
- 🐱‍👓思路解析：
- 🐱‍🏍代码实现：
⭕总结

🌏引言

二叉树的操作算法是笔试面试中较为常见的题目。
本文将着重介绍平时面试中常见的关于二叉树的应用题目，马上要进行秋招了。希望对你们有帮助 _😀
在这里插入图片描述

🍀相同的树

🐱‍🐉题目描述：

给你两棵二叉树的根节点 p 和 q ，编写一个函数来检验这两棵树是否相同。

如果两个树在结构上相同，并且节点具有相同的值，则认为它们是相同的。

/**
 * 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 isSameTree(TreeNode p, TreeNode q) {

    }
}

🐱‍👓示例：

📌示例一

在这里插入图片描述

📌示例二

在这里插入图片描述

📌示例三

在这里插入图片描述

🐱‍👤题目解析

这道题我们利用递归的思想，遍历两棵树的每一个结点，分别对两棵树相对应结点进行判断

对于结点的判断我们有如下几个情况

有一个结点为null，这时候直接返回false；
两个结点都为null，这时候直接返回true；
都不为空时进行判断，若不等返回false；

整体思想，若两棵树左子树与右子树全部相等就返回true

🚩代码实现：

/**
 * 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 isSameTree(TreeNode p, TreeNode q) {
        if(p != null&&q == null||p == null&&q != null) {
            return false;
        }
        if(p == null && q == null) {
            return true;
        }
        if(p.val != q.val) {
            return false;
        }
        return isSameTree(p.left,q.left) && isSameTree(p.right,q.right);
    }
}

🌳另一棵树的子树

🐱‍👤题目描述：

给你两棵二叉树 root 和 subRoot 。检验 root 中是否包含和 subRoot 具有相同结构和节点值的子树。如果存在，返回 true ；否则，返回 false 。

二叉树 tree 的一棵子树包括 tree 的某个节点和这个节点的所有后代节点。tree 也可以看做它自身的一棵子树。

/**
 * 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 isSubtree(TreeNode root, TreeNode subRoot) {

    }
}

🐱‍🐉示例：

📌示例一

在这里插入图片描述

📌示例二

在这里插入图片描述

🐱‍👓解法思路：

其实这道题与上一题的解法思路类似

我们只需要传入相应的头节点与子树进行对比看看是否为同一棵树就好

只要存在就返回true

在这里插入图片描述

🐱‍🐉代码实现

/**
 * 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 isSubtree(TreeNode root, TreeNode subRoot) {
        if(root == null || subRoot == null) {
            return false;
        }
        //相同树
        if(isSameTree(root,subRoot)) {
            return true;
        }
        //含子树
        return isSubtree(root.left,subRoot)||isSubtree(root.right,subRoot);
    }
    public boolean isSameTree(TreeNode p, TreeNode q) {
        if(p != null&&q == null||p == null&&q != null) {
            return false;
        }
        if(p == null && q == null) {
            return true;
        }
        if(p.val != q.val) {
            return false;
        }
        return isSameTree(p.left,q.left) && isSameTree(p.right,q.right);
    }
}

🎍翻转二叉树

🐱‍👤题目描述：

给你一棵二叉树的根节点 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) {

    }
}

🐱‍👓示例：

在这里插入图片描述

🐱‍🐉思路解析：

依旧利用递归的思想，把一个大树看成许多小树

我们只需要把每一个根节点的左子树和右子树进行交换就好
在这里插入图片描述

🐱‍🏍代码实现

/**
 * 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 tep = root.left;
        root.left = root.right;
        root.right = tep;
        
        invertTree(root.left);
        invertTree(root.right);

        return root;
    }
}

🎄平衡二叉树

🐱‍👤题目描述

给定一个二叉树，判断它是否是高度平衡的二叉树。

本题中，一棵高度平衡二叉树定义为：

一个二叉树每个节点的左右两个子树的高度差的绝对值不超过 1 。

🐱‍🐉示例：

📌示例一

在这里插入图片描述

📌示例二

在这里插入图片描述

📌示例三

在这里插入图片描述

🐱‍👓思路解析：

🎈思路一

自顶向下，具体做法类似于二叉树的前序遍历，即对于当前遍历到的节点，首先计算左右子树的高度，如果左右子树的高度差是否不超过 111，再分别递归地遍历左右子节点，并判断左子树和右子树是否平衡。这是一个自顶向下的递归的过程。

利用递归思想进行逐个遍历，但是这时候的时间复杂度较高，为O(N^2);

🎈思路二

自底向上，自底向上递归的做法类似于后序遍历，对于当前遍历到的节点，先递归地判断其左右子树是否平衡，再判断以当前节点为根的子树是否平衡。如果一棵子树是平衡的，则返回其高度（高度一定是非负整数），否则返回 −1。如果存在一棵子树不平衡，则整个二叉树一定不平衡。

然后返回即可，此时的时间复杂度为O(N)

🐱‍🏍代码实现

🚩思路一实现：

/**
 * 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 isBalanced(TreeNode root) {
        if(root == null) {
            return true;
        } 
        int l = maxDepth(root.left);
        int r = maxDepth(root.right);
        return Math.abs(l - r) < 2 && isBalanced(root.left) &&isBalanced(root.right);
    }
        public int maxDepth(TreeNode root) {
        if(root == null) {
            return 0;
        }
        int leftHeight = maxDepth(root.left);
        int rightHeight = maxDepth(root.right);

        return (leftHeight > rightHeight) ?
                (leftHeight+1):(rightHeight+1);
    }

}

🚩思路二实现：

class Solution {
    public boolean isBalanced(TreeNode root) {
        return height(root) >= 0;
    }

    public int height(TreeNode root) {
        if (root == null) {
            return 0;
        }
        int leftHeight = height(root.left);
        int rightHeight = height(root.right);
        if (leftHeight == -1 || rightHeight == -1 || Math.abs(leftHeight - rightHeight) > 1) {
            return -1;
        } else {
            return Math.max(leftHeight, rightHeight) + 1;
        }
    }
}

🌲对称二叉树

🐱‍👤题目描述

给你一个二叉树的根节点 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 boolean isSymmetric(TreeNode 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 boolean isSymmetric(TreeNode root) {
        return issymmetric(root.left,root.right);
    }
    public boolean issymmetric(TreeNode l,TreeNode r) {
        if(l != null&&r == null || l == null && r != null) {
            return false;
        }
        if(l == null && r == null ) {
            return true;
        }
        if(l.val != r.val ) {
            return false;
        }
        return issymmetric(l.left,r.right) && issymmetric(l.right,r.left);
    }
}

🎡二叉树的层序遍历

🐱‍👤题目描述：

给你二叉树的根节点 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 List<List<Integer>> levelOrder(TreeNode root) {

    }
}

🐱‍🐉示例：

在这里插入图片描述

🐱‍👓思路解析：

我们创建一个队列，用于储存每一层二叉树的结点，每一次当我们将头元素进行出队后，我们又会将下一层的结点进行入队，然后依次进行遍历，直到队列为null则结束循环

在这里插入图片描述

先将根节点root进入到该队列，创建一个list顺序表里面的元素也为顺序表，每一个元素用于储存每一层的结点

此后会在一个while循环里对该二叉树进行遍历，结束循环的条件为队列为空，
做法为

我们每一次循环都会求一次队列的长度
创建一个顺序表tmp进行储存该层结点
在循环里再来一个循环，目的是：
把当前队列里存储的结点出队到tmp里面进行存储
把下一层二叉树的结点进行入队
该内while循环结束后tmp里面储存的就是该层的二叉树的所有元素
此时再将tmp添加到list顺序表里即可
此时第一层二叉树遍历完毕，队列不为空
继续执行外层循环

🐱‍🏍代码实现：

/**
 * 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 List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> list = new ArrayList<>();
        Queue<TreeNode> queue = new LinkedList<>();
        if(root == null) {
            return list;
        }
        queue.offer(root);
        TreeNode cur = root;
        while(!queue.isEmpty()) {
            int size = queue.size();
            List<Integer> tmp = new ArrayList<>();
            while(size != 0) {
                cur = queue.poll();
                tmp.add(cur.val);
                size--;
                if(cur.left != null) {
                    queue.offer(cur.left);
                }
                if(cur.right != null) {
                    queue.offer(cur.right);
                }
            }
            list.add(tmp);
        }
        return list;
    }
}