【LeetCode怎么刷】递归的趣味之对称二叉树_仗剑走天涯对称-优快云博客

本文链接：https://blog.youkuaiyun.com/mrjeremy/article/details/87992761

微信公众号：最优代码
让你感受对代码精益求精的极致优化之旅,感受深入浅出的奥秘,分享Java、算法、重构、分布式、高并发等基础与优化干货;

内容目录

LeetCode怎么刷之对称二叉树题目描述输入输出递归求解思路分析递归详解代码展示复杂度分析时间复杂度空间复杂度迭代法思路分析迭代详解代码展示复杂度分析时间复杂度空间复杂度总结递归如何去写方法论创建链表的例子链表翻转的例子提问关于最优代码

LeetCode怎么刷之对称二叉树

题目描述

给定一个二叉树，检查它是否是镜像对称的。

输入输出

例如，二叉树 [1,2,2,3,4,4,3] 是对称的。
　　　　1
　　　/ 　\
　　2　　　2
　/　 \ 　/　 \
　3　4　　4　3

但是下面这个 [1,2,2,null,3,null,3] 则不是镜像对称的:
　　　　　１
　　　　/　　\
　　　2　　　2
　　/ 　\ 　/ 　\
　3　　　　3

递归求解

思路分析

递归详解

如果一个树的左子树与右子树镜像对称，那么这个树是对称的。

因此，该问题可以转化为：两个树在什么情况下互为镜像？

如果同时满足下面的条件，两个树互为镜像：

１.它们的两个根结点具有相同的值。
２.每个树的右子树都与另一个树的左子树镜像对称。

就像人站在镜子前审视自己那样。镜中的反射与现实中的人具有相同的头部，但反射的右臂对应于人的左臂，反之亦然。

代码展示

/**
 * 节点定义
 */
   public class TreeNode {
       int val;
       TreeNode left;
       TreeNode right;
       TreeNode(int x) { val = x; }
   }

     /**
     * 递归
     */
    public boolean isSymmetric_1(TreeNode root) {
        return isSymmetric(root, root);
    }

    /**
     * 该方法亦可用以比较两棵树是否对称
     */
    private boolean isSymmetric(TreeNode root1, TreeNode root2) {
        if (root1 == null && root2 == null) {
            return true;
        } else if (root1 == null || root2 == null) {
            return false;
        } else if (root1.val != root2.val) {
            return false;
        }
        // 递归，就该节点而言，只需要关注自己的左右孩子是否对称即可
        return isSymmetric(root1.left, root2.right) && isSymmetric(root1.right, root2.left);
    }

复杂度分析

时间复杂度

O(n)，对这个树中的每个节点都要进行遍历。

空间复杂度

最坏为O(n)，此时树是一个线性树?，就是一个很长很长的?。

迭代法

思路分析

迭代详解

除了递归的方法外，我们也可以利用队列进行迭代。队列中每两个连续的结点应该是相等的，而且它们的子树互为镜像。最初，队列中包含的是 root 以及 root。该算法的工作原理类似于 BFS，但存在一些关键差异。每次提取两个结点并比较它们的值。然后，将两个结点的左右子结点按相反的顺序插入队列中。当队列为空时，或者我们检测到树不对称（即从队列中取出两个不相等的连续结点）时，该算法结束。

代码展示

/**
 * 节点定义
 */
   public class TreeNode {
       int val;
       TreeNode left;
       TreeNode right;
       TreeNode(int x) { val = x; }
   }

public boolean isSymmetric(TreeNode root) {
    Queue<TreeNode> q = new LinkedList<>();
    q.add(root);
    q.add(root);
    while (!q.isEmpty()) {
        TreeNode t1 = q.poll();
        TreeNode t2 = q.poll();
        if (t1 == null && t2 == null) continue;
        if (t1 == null || t2 == null) return false;
        if (t1.val != t2.val) return false;
        q.add(t1.left);
        q.add(t2.right);
        q.add(t1.right);
        q.add(t2.left);
    }
    return true;
}

复杂度分析

时间复杂度

O(n)，需要把整个树给遍历一次。

空间复杂度

O(n)，在最坏情况下要向队列中插入n个节点。

总结

递归如何去写

方法论

【先一般】，【后特殊】（即边界）
先写递归的主体部分，再回头写边界（一行行读主体部分的代码，寻找特殊的边界情况）
每次调用【必须缩小】问题规模
每次问题规模缩小程度必须为【1】（不要贪心）
这里的1并不是狭义的，比方说如果二分查找的时候，每次缩小一半的规模也是可以的。

创建链表的例子

具体说明
我们需要创建一个3节点的单向链表，如head->1->2->3->null.
假设此时我们得到的是2个节点的单向链表,为head->2->3->null.
那么此时我们只需要将第一个节点的next指针指向（n-1）结果的头节点即可
【先一般】代码说明

public ListNode createLinkedList(List<Integer> data) { 
        ListNode firstNode = new Node(data.get(0)); 
        // 将第一个节点的next指针指向n-1已经创建好链表的头节点 
        firstNode.next = createLinkedList(data.subList(1, data.size()));  
        return firstNode; // 返回头节点 
    }

步骤进阶
此时我们【先一般】的步骤就完成了，接下来就是寻找特殊（边界）情况了，一行行代码看下来发现head和head.next为null时会报异常，于是就得处理异常情况，即为【后特殊】。
【后特殊】代码说明

public ListNode createLinkedList(List<Integer> data) { 
        if (data.isEmpty()) 
            return null; 
        ListNode firstNode = new Node(data.get(0)); 
        // 将第一个节点的next指针指向n-1已经创建好链表的头节点 
        firstNode.next = createLinkedList(data.subList(1, data.size()));  
        return firstNode; // 返回头节点 
    }

链表翻转的例子

具体说明
把1->2->3->null翻转成null<-1<-2<-3. 假设此时我们已经把n-1个节点已经翻转完毕null<-2<-3. 那么此时我们应该怎么做呢？此时1这个元素的next指针还是指向2的，因为后面的反转并不会影响1元素的next指针： 1->2,而null<-2<-3.
所以此时我们只需要将节点2的next设为1，将节点1的next设为null即可完成反转，变成null<-1<-2<-3.
【先一般】代码说明

public ListNode ReverseList(ListNode head) { 
        // 这里得到n-1反转后链表的头节点，也就是反转前的最后一个节点 
        ListNode newHead = ReverseList(head.next); 
        // 将节点2的next设为节点1 
        head.next.next = head; 
        // 将节点1的next设为null 
        head.next = null; 
        return newHead; 
    }

步骤进阶
那么此时【先一般】就完成了，接下来就是寻找【后特殊】（边界）情况了，一行行代码看下来发现head和head.next为null时会报异常。
【特殊】代码说明

public ListNode ReverseList(ListNode head) { 
        if(head == null || head.next == null) 
            return head; 
        ListNode newHead = ReverseList(head.next); 
        head.next.next = head; 
        head.next = null; 
        return newHead; 
    }