对称二叉树（Leetcode 101&&572）

题目

101. 对称二叉树

思路

使用层序遍历，遍历当前层的节点时，如该节点的左（右）孩子为空，在list中添加null，否则加入左（右）孩子的值。每遍历完一层则对当前list进行判断，这里判断我用了一个很笨的方法，前面记录下一层节点值时就设置了两个list，其中一个用来翻转，然后判断这两个list是否相等来判断数是否为对称树。

去看了解析，有两种方法：递归法、使用双端队列进行迭代。

代码

public boolean isSymmetric(TreeNode root) {
//        迭代写法：使用双端队列
        if(root == null){return true;}
        Deque<TreeNode> deque = new LinkedList<TreeNode>();
        deque.offerFirst(root.left);
        deque.offerLast(root.right);
        while (!deque.isEmpty()){
            TreeNode temp_left = deque.pollFirst();
            TreeNode temp_right = deque.pollLast();

            if(temp_left == null && temp_right == null){continue;}
            if(temp_left == null || temp_right == null || temp_left.val != temp_right.val){return false;}

            deque.offerFirst(temp_left.right);
            deque.offerFirst(temp_left.left);
            deque.offerLast(temp_right.left);
            deque.offerLast(temp_right.right);
        }
        return true;

    }

    public boolean isSymmetric_2(TreeNode root) {
//        递归写法：分解为判断每个子树是否对称
        if(root == null){return true;}
        return comp(root.left, root.right);
    }
    public boolean comp(TreeNode left, TreeNode right){
        if(left == null && right != null){return false;}
        if(left != null && right == null) {return false;}
        if(left == null && right == null){return true;}
        if(left.val != right.val){return false;}
//        当左右子树都不为空且值相等时，对其左右子树继续进行判断
        return comp(left.left, right.right)&&comp(left.right, right.left);
    }
    public boolean isSymmetric_1(TreeNode root) {
//        判断二叉树是否为轴对称二叉树
//        直接拿层序遍历的结果，看逆转后是否还为原数组来进行判断
        if(root == null){return false;}
        Queue<TreeNode> queue = new ArrayDeque<TreeNode>();
        queue.add(root);
        while (!queue.isEmpty()){
            int len = queue.size();
   
            List<Integer> temp_list = new ArrayList<Integer>();
            List<Integer> temp_re = new ArrayList<Integer>();
            while (len > 0){
                TreeNode temp = queue.poll();

                if(temp.left == null){temp_list.add(null);temp_re.add(null);}
                if(temp.left != null){queue.add(temp.left);temp_list.add(temp.left.val);temp_re.add(temp.left.val);}
                if(temp.right == null){temp_list.add(null);temp_re.add(null);}
                if(temp.right != null){queue.add(temp.right);temp_list.add(temp.right.val);temp_re.add(temp.right.val);}
                len--;
            }
          
            Collections.reverse(temp_list);
            if(!temp_list.equals(temp_re)){
                return false;
            }

        }
        return true;

    }

题目 

572. 另一棵树的子树

 思路

与对称二叉树比较相似，最开始想的是对第一棵树进行层序遍历，找到与子树根节点值一样的节点后，通过同时遍历（这里最开始用的双向队列 但是有问题 后面改成使用两个队列分别存储两棵树的节点情况 循环截至的条件为子树遍历完成）这两棵树来进行判断。 

后面看了题解，第一种是深度遍历然后匹配，确实层序遍历比较冗余。太久没写也不会写深度遍历了，搞半天前序、中序、后序遍历都是深度遍历！写起来也不是很顺畅，就照着答案敲了一遍，确实比较优雅。

第二种是将该问题转化为字符串匹配问题，使用KMP（救命，每次学了就忘学了就忘），我只能说泰裤辣！

代码

// 我的垃圾代码
class Solution {
    public boolean isSubtree(TreeNode root, TreeNode subRoot) {
        // 层序遍历root子树 找到与subRoot根节点相同的节点
        // 队列存储数节点
        Queue<TreeNode> queue = new LinkedList<>();
        queue.add(root);
        while(!queue.isEmpty()){
            TreeNode node = queue.poll();
            if(node.val == subRoot.val){
                if(is_same(node, subRoot)){
                    return true;
                }
            }
            if(node.left != null){queue.add(node.left);}
            if(node.right != null){queue.add(node.right);}
        }
        return false;
    }

    private boolean is_same(TreeNode root, TreeNode subRoot) {
        Queue<TreeNode> deque_1 = new LinkedList<>();
        Queue<TreeNode> deque_2 = new LinkedList<>();
        deque_1.add(root);
        deque_2.add(subRoot);

        while (!deque_2.isEmpty()){
            TreeNode node_1 = deque_1.poll();
            TreeNode node_2 = deque_2.poll();

            if(node_1 == null && node_2 == null){continue;}
            if(node_1 == null || node_2 == null || node_1.val != node_2.val){return false;}

            deque_1.add(node_1.left);
            deque_1.add(node_1.right);
            deque_2.add(node_2.left);
            deque_2.add(node_2.right);

        }
        return true;
    }

}

// 深度遍历
class Solution {
    public boolean isSubtree(TreeNode root, TreeNode subRoot) {
        // 题解说深度优先遍历
        return dfs(root, subRoot);

    }

    private boolean dfs(TreeNode root, TreeNode subRoot) {
        if (root == null){
            return false;
        }
        return check(root, subRoot) || check(root.left, subRoot) || check(root.right, subRoot);
    }

    private boolean check(TreeNode root, TreeNode subRoot) {
        if(root == null && subRoot == null){return true;}
        if(root == null || subRoot == null || root.val != subRoot.val){return false;}
        
        return check(root.left, subRoot.left) && check(root.right, subRoot.right);
    }
}

KMP算法

 

public boolean kmp() {
        int sLen = sOrder.size(), tLen = tOrder.size();
        int[] next = new int[tOrder.size()];
        // 初始化
        next[0] = 0;
        for (int i = 1, j = 0; i < tLen; i++) {
            while (j > 0 && !(tOrder.get(i).equals(tOrder.get(j)))) {
                // i != j时，j回退到下标 为next数组前一位的值
                j = next[j-1];
            }
            if (tOrder.get(i).equals(tOrder.get(j))) {
                // i == j j++ 更新next数组
                j++;
            }
            next[i] = j;
        }
        // 根据next数组进行匹配 i指向s j指向模式串t
        for (int i = 0, j = 0; i < sLen; i ++) {
            while (j > 0 && !(sOrder.get(i).equals(tOrder.get(j)))) {
                // 不匹配时 j回退到next数组前一位值的下标
                j = next[j-1];
            }
            if (sOrder.get(i).equals(tOrder.get(j))) {
                // 相等j就继续向后走
                j++;
            }
            if (j == tLen) {
                // 如果模式串全部都匹配 j会++ 所以这里判断是j == tLen 
                return true;
            }
        }
        return false;
    }