LeetCode 951. Flip Equivalent Binary Trees (Medium)

二叉树翻转等价判断

最新推荐文章于 2021-08-02 19:37:13 发布

原创最新推荐文章于 2021-08-02 19:37:13 发布 · 188 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#leetcode

LeetCode 专栏收录该内容

40 篇文章

订阅专栏

本文介绍了一种算法，用于确定两棵二叉树是否通过一系列节点的左右子树交换操作达到等价状态。首先将每棵树转换为其规范形式，确保每个只有一个子节点的节点的子节点在其左侧，且左子节点的值小于等于右子节点的值。然后，进行先序遍历并比较结果，以判断两棵树是否等价。

Description:
For a binary tree T, we can define a flip operation as follows: choose any node, and swap the left and right child subtrees.

A binary tree X is flip equivalent to a binary tree Y if and only if we can make X equal to Y after some number of flip operations.

Write a function that determines whether two binary trees are flip equivalent. The trees are given by root nodes root1 and root2.

Example 1:

Input: root1 = [1,2,3,4,5,6,null,null,null,7,8], root2 = [1,3,2,null,6,4,5,null,null,null,null,8,7]
Output: true
Explanation: We flipped at nodes with values 1, 3, and 5.

在这里插入图片描述 Note:

Each tree will have at most 100 nodes.
Each value in each tree will be a unique integer in the range [0, 99].

Analysis:
Here we define a canonical form of a tree:

If a node has only one son node, then the son node must be its left son.
If a node has two son nodes, make sure the value of its left son node is lower than or equal to the value of its right son node.

1.Firstly, transform each tree to its canonical form, like the following image shows.
2.Secondly, do the pre-order traversal to each tree and then compare the results.(list1.equals(list2))

Code:

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public boolean flipEquiv(TreeNode root1, TreeNode root2) {
        if(root1 == null && root2 == null) {
            return true;
        }else if(root1 == null && root2 != null) {
            return false;
        }else if(root1 != null && root2 == null) {
            return false;
        }else{
            List<Integer> tree1 = new ArrayList<>();
            List<Integer> tree2 = new ArrayList<>();
            
            buildCanonicalTree(root1, tree1);
            buildCanonicalTree(root2, tree2);
            
            return tree1.equals(tree2);
        }
    }
    
    public void buildCanonicalTree(TreeNode node, List<Integer>tree) {
        tree.add(node.val);
        if(node.left != null && node.right != null) {
            if(node.left.val > node.right.val) {
                TreeNode temp = node.right;
                node.right = node.left;
                node.left = temp;
            }
        }else if(node.left == null && node.right != null) {
            node.left = node.right;
            node.right = null;
        }
        if(node.left != null) {
            buildCanonicalTree(node.left, tree);
        }
        if(node.right != null) {
            buildCanonicalTree(node.right, tree);
        }
    }
}