算法10：LeetCode_相同的树（力扣100题）

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

如果两个树在结构上相同，并且节点具有相同的值，则认为它们是相同的。具体示例可以参考LeetCode原题给的例子https://leetcode.cn/problems/same-tree/

package code.code_03;

/**
 * LeetCode : https://leetcode.cn/problems/same-tree/
 *
 * 给你两棵二叉树的根节点 p 和 q ，编写一个函数来检验这两棵树是否相同。
 * 如果两个树在结构上相同，并且节点具有相同的值，则认为它们是相同的。
 *
 * 具体demo参照力扣原题
 */
public class Code02_SameTree {

     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;
        }
     }

    public boolean isSameTree(TreeNode p, TreeNode q)
    {
        if (p == null && q == null) {
            return true;
        }

        if ((p == null && q != null)
                || (p != null && q == null)
                || p.val != q.val){
            return false;
        }

        /**
         * 递归调用二叉树
         *
         *                    1
         *                /      \
         *              2          3
         *            /  \       /    \
         *          4     5     6       7
         *        /  \   / \    / \    /  \
         *       8   9  10  11 12  13 14   15
         *
         *                             1
         *                         /      \
         *                       2          3
         *                     /  \       /    \
         *                   4     5     6       7
         *                 /  \   / \    / \    /  \
         *                8   9  10  11 12  13 14   15
         *
         *  左子树的书序为 2 ->4 ->8 ->9 ->5 ->10 ->11
         *  右子树的顺序为 3 ->6 ->12 ->13 ->7 ->14 ->15
         *  整棵树的顺序为 1 ->2 ->4 ->8 ->9 ->5 ->10 ->11 ->3 ->6 ->12 ->13 ->7 ->14 ->15
         *
         * 1. 先从上到下遍历左子树的所有左节点，如果不同，则两棵树不等；
         * 2. 如果所有的左子树的左节点都相同，则返回上一层，开始遍历左子树最下方根节点的右节点
         * 3. 如果还是相同，则再返回上一层，遍历左子树的右节点 （此时，右节点可能也有左、右子节点，类似于上图5节点下挂的10和11， 此时继续先左后右遍历，以此类推）
         *
         * 4. 左子树的所有节点比例完以后，如果不同，则直接返回
         * 5. 如果还是相等，则开始遍历右子树
         * 6. 遍历右子树的时候，还是先左后右，如果右子树的左节点右不相等的，直接返回false；
         * 7. 如果右子树的所有左节点全部相同，返回上一层开始遍历右子树最下方根节点的右节点（类似于步骤2）
         * 8. 如果继续相同，则再返回上一层，遍历右子树的右节点 （此时，右子树的也可能右左右节点，类似于上图7节点下挂14和15，此时依旧先左后右，以此类推）
         */
        System.out.println("当前遍历的节点值为 ： " + p.val);
        return isSameTree(p.left, q.left) && isSameTree(p.right, q.right);
    }

    public static void main(String[] args) {
        Code02_SameTree tree = new Code02_SameTree();
        TreeNode node1 = tree.new TreeNode(1);
        TreeNode node2 = tree.new TreeNode(2);
        TreeNode node3 = tree.new TreeNode(3);
        TreeNode node4 = tree.new TreeNode(4);
        TreeNode node5 = tree.new TreeNode(5);
        TreeNode node6 = tree.new TreeNode(6);
        TreeNode node7 = tree.new TreeNode(7);
        TreeNode node8 = tree.new TreeNode(8);
        TreeNode node9 = tree.new TreeNode(9);
        TreeNode node10 = tree.new TreeNode(10);
        TreeNode node11 = tree.new TreeNode(11);
        TreeNode node12 = tree.new TreeNode(12);
        TreeNode node13 = tree.new TreeNode(13);
        TreeNode node14 = tree.new TreeNode(14);
        TreeNode node15 = tree.new TreeNode(15);

        node1.left = node2; node1.right = node3;
        node2.left = node4; node2.right = node5;
        node4.left = node8; node4.right = node9;
        node5.left = node10; node5.right = node11;

        node3.left = node6; node3.right = node7;
        node6.left = node12; node6.right = node13;
        node7.left = node14; node7.right = node15;

        TreeNode v1 = tree.new TreeNode(1);
        TreeNode v2 = tree.new TreeNode(2);
        TreeNode v3 = tree.new TreeNode(3);
        TreeNode v4 = tree.new TreeNode(4);
        TreeNode v5 = tree.new TreeNode(5);
        TreeNode v6 = tree.new TreeNode(6);
        TreeNode v7 = tree.new TreeNode(7);
        TreeNode v8 = tree.new TreeNode(8);
        TreeNode v9 = tree.new TreeNode(9);
        TreeNode v10 = tree.new TreeNode(10);
        TreeNode v11 = tree.new TreeNode(11);
        TreeNode v12 = tree.new TreeNode(12);
        TreeNode v13 = tree.new TreeNode(13);
        TreeNode v14 = tree.new TreeNode(14);
        TreeNode v15 = tree.new TreeNode(15);

        v1.left = v2; v1.right = v3;
        v2.left = v4; v2.right = v5;
        v4.left = v8; v4.right = v9;
        v5.left = v10; v5.right = v11;

        v3.left = v6; v3.right = v7;
        v6.left = v12; v6.right = v13;
        v7.left = v14; v7.right = v15;

        boolean isSame = tree.isSameTree(node1, v1);
        System.out.println("they are the same true ? " + isSame);
    }
}

代码里面备注信息充足，相信通过仔细阅读，一定会大有收获