【LeetCode】【HOT】101. 对称二叉树（BFS+队列/递归）

【LeetCode】【HOT】101. 对称二叉树

package hot;

class TreeNode{
    int val;
    TreeNode left;
    TreeNode right;

    TreeNode(int val){
        this.val = val;
    }
}

import java.util.LinkedList;
import java.util.Queue;

public class Solution101 {
    public static void main(String[] args) {
        TreeNode node1 = new TreeNode(1);
        TreeNode node2 = new TreeNode(2);
        TreeNode node3 = new TreeNode(2);
        TreeNode node4 = new TreeNode(3);
        TreeNode node5 = new TreeNode(4);
        TreeNode node6 = new TreeNode(4);
        TreeNode node7 = new TreeNode(3);
        node1.left = node2;
        node1.right = node3;
        node2.left = node4;
        node2.right = node5;
        node3.left = node6;
        node3.right = node7;
        Solution101 solution = new Solution101();
        System.out.println(solution.itera(node1, node1));
        System.out.println(solution.recur(node1, node1));
    }

    private boolean itera(TreeNode p, TreeNode q){
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(p);
        queue.offer(q);
        while(!queue.isEmpty()){
            p = queue.poll();
            q = queue.poll();
            if(p == null && q == null) continue;
            if((p == null || q == null) || (p.val != q.val)) return false;
            queue.offer(p.left);
            queue.offer(q.right);
            queue.offer(p.right);
            queue.offer(q.left);
        }
        return true;
    }
    //时间复杂度为 O(n)
    //空间复杂度为 O(n)

    private boolean recur(TreeNode p, TreeNode q){
        if(p == null && q == null) return true;
        if(p == null || q == null) return false;
        return p.val == q.val && recur(p.left, q.right) && recur(p.right, q.left);
    }
    //时间复杂度为 O(n)
    //空间复杂度为 O(n)
}