二叉树的水平阶差确定对称性

如何解决二叉树的水平阶差确定对称性

我试图找出一棵树是否是迭代对称的。我的方法包括一个级别顺序遍历，其中使用两个队列，第二个队列包含每个级别的所有元素，并将它们发送到isSymmetric函数，该函数使用该队列（q2）来确定所包含的元素是否是回文。如果不是，则返回false，主函数可以返回false。

问题（我怀疑有不止一个-请指出）！

node.left ==空&& node.right！=空

和

arr [i] = current.remove（）。val;

给出一个OutOfBoundsException，但我不确定为什么。 另外，我将使用Integer.MIN_VALUE值创建一个新的TreeNode（如果它为空），这是因为我想考虑当两端的值相同但位置不正确时的情况。

链接到有关leetcode的问题：https://leetcode.com/problems/symmetric-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 isSymmetric(TreeNode root) {
    //bfs and each array in bfs should be palindromic
        Queue<TreeNode> q = new LinkedList<>();
        q.add(root);
        boolean symmetric = false;
        Queue<TreeNode> q2 = new LinkedList<>();
        
        while(!q.isEmpty()) {
            
            TreeNode node = q.remove();

            if(node.left == null && node.right != null) {
                q2.add(new TreeNode(Integer.MIN_VALUE));
            }
            else if(node.left != null && node.right == null) {
                q2.add(new TreeNode(Integer.MIN_VALUE));
            }
            else {
                q2.add(node.left);
                q2.add(node.right);
            }
            
            if(q.isEmpty()) {
                q = q2;
                symmetric = isTreeSymmetric(q2);
                if(symmetric == false) {
                    return false;
                }
            }
            
            if(q2.isEmpty() && q.isEmpty()) {
                return true;
            }
        }
        return false;
    }
    
    public static boolean isTreeSymmetric(Queue<TreeNode> current) {
        int[] arr = new int[current.size()];
         System.out.println("current-size= " + current.size());
        for(int i = 0; i < current.size(); i++) {
            System.out.println(arr[i]);
            arr[i] = current.remove().val;
        }
        
        int i = 0;
        int j = current.size() - 1;
        
        while(i < j) {
            if(arr[i] != arr[j]) {
                return false;
            }
        }
        return true;
    }
}

解决方法

我们还可以使用递归，这样会容易得多：

public class Solution {
    public static final boolean isSymmetric(
        final TreeNode root
    ) {
        return root == null ||
               isTreeSymmetric(root.left,root.right);
    }

    private static final boolean isTreeSymmetric(
        final TreeNode left,final TreeNode right
    ) {
        if (left == null || right == null) {
            return left == right;
        }

        if (left.val != right.val) {
            return false;
        }

        return isTreeSymmetric(left.left,right.right) &&
               isTreeSymmetric(left.right,right.left);
    }
}