剑指 Offer 26. 树的子结构 / 剑指 Offer 27. 二叉树的镜像 / 剑指 Offer 28. 对称的二叉树 / 剑指 Offer 29. 顺时针打印矩阵

Posted 2021-06-21 Zephyr丶J

剑指 Offer 26. 树的子结构

题目描述

输入两棵二叉树A和B，判断B是不是A的子结构。(约定空树不是任意一个树的子结构)

B是A的子结构， 即 A中有出现和B相同的结构和节点值。

例如:
给定的树 A:

     3
    / \\
   4   5
  / \\
 1   2
给定的树 B：

   4 
  /
 1
返回 true，因为 B 与 A 的一个子树拥有相同的结构和节点值。

示例 1：

输入：A = [1,2,3], B = [3,1]
输出：false
示例 2：

输入：A = [3,4,5,1,2], B = [4,1]
输出：true

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/shu-de-zi-jie-gou-lcof
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

思路

看到就想到的思路就是递归的判断，如果根节点相同，那么就往左右节点判断，然后我就写出了下面的代码

class Solution {
    public boolean isSubStructure(TreeNode A, TreeNode B) {
        //递归的判断，如果根节点相同，就判断左边右边结点是否也相同
        if(B == null)
            return true;
        if(A == null)
            return false;
        if(A.val != B.val){
            return isSubStructure(A.left, B) || isSubStructure(A.right, B);
        }else{
            return isSubStructure(A.left, B.left) && isSubStructure(A.right, B.right);
        }
    }
}

然后不出意外，挂了，倒在了B为空的示例上，因为题目中给出B为空，是false。但是在递归的过程中，B为空必须得返回tru，因此我把这部分重写了一个方法，又得到了下面的代码

class Solution {
    public boolean isSubStructure(TreeNode A, TreeNode B) {
        //递归的判断，如果根节点相同，就判断左边右边结点是否也相同
        if(B == null)
            return false;
        if(A == null)
            return false;
        return subtree(A, B);
    }

    public boolean subtree(TreeNode A, TreeNode B){
        if(B == null)
            return true;
        if(A == null)
            return false;
        if(A.val != B.val){
            return subtree(A.left, B) || subtree(A.right, B);
        }else{
            return subtree(A.left, B.left) && subtree(A.right, B.right);
        }
    }
}

然后又挂了，倒在了[4,2,3,4,5,6,7,8,9] [4,8,9]这个示例上，这是因为啥呢，这是因为我是在左子树上找B的左半部分，右子树上找B的右半部分，显然不对，然后又改

class Solution {
    public boolean isSubStructure(TreeNode A, TreeNode B) {
        //递归的判断，如果根节点相同，就判断左边右边结点是否也相同
        if(B == null)
            return false;
        if(A == null)
            return false;
        return subtree(A, B);
    }

    public boolean subtree(TreeNode A, TreeNode B){
        if(B == null)
            return true;
        if(A == null)
            return false;
        if(A.val != B.val){
            return subtree(A.left, B) || subtree(A.right, B);
        }else{
            return (subtree(A.left, B.left) && subtree(A.right, B.right)) || subtree(A.left, B) || subtree(A.right, B);
        }
    }
}

还是倒在了最后一个示例上[1,0,1,-4,-3] [1,-4]，这次倒下其实是预料之中，因为按照我写的代码，如果根节点相同的话，我是在左右子树找剩下的部分，而这个部分不和根节点相邻我的代码也会返回true，所以继续改，这次是改成遍历所有的节点，然后判断了，这次过了
最后想想，树的题目本身比较难，这个题其实用了先序遍历+判断子树的方法，子树是一个连续的结构，不能拆开，继续加油吧

class Solution {
    public boolean isSubStructure(TreeNode A, TreeNode B) {
        //递归的判断，如果根节点相同，就判断左边右边结点是否也相同
        if(B == null)
            return false;
        if(A == null)
            return false;
        //需要遍历每一个节点
        return subtree(A, B) || isSubStructure(A.left, B) || isSubStructure(A.right, B);
    }

    public boolean subtree(TreeNode A, TreeNode B){
        if(B == null)
            return true;
        if(A == null)
            return false;
        if(A.val != B.val){
            return false;
        }else{
            return subtree(A.left, B.left) && subtree(A.right, B.right);
        }
    }
}

剑指 Offer 27. 二叉树的镜像

题目描述

请完成一个函数，输入一个二叉树，该函数输出它的镜像。

例如输入：

     4
   /   \\
  2     7
 / \\   / \\
1   3 6   9
镜像输出：

     4
   /   \\
  7     2
 / \\   / \\
9   6 3   1


示例 1：

输入：root = [4,2,7,1,3,6,9]
输出：[4,7,2,9,6,3,1]

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/er-cha-shu-de-jing-xiang-lcof
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

思路

观察可知，镜像就是将左右子树交换，层层交换就可以得到结果，然后写了这个代码

class Solution {
    public TreeNode mirrorTree(TreeNode root) {
        //一层一层翻转
        if(root == null)
            return null;
        TreeNode leftTree = root.left;
        root.left = root.right;
        root.right = leftTree;
        mirrorTree(root.left);
        mirrorTree(root.right);
        return root;
    }
}

过了，但是这里有个问题，就是这个方法是有返回值的，但是这里面调用方法的时候，并没有返回值，为什么还行的通，然后就去查了一下，有返回值的方法，可以选择用不用，没有返回值的方法，不能用

class Solution {
    public TreeNode mirrorTree(TreeNode root) {
        //先将底层翻转，自底向上
        if(root == null)
            return null;
        TreeNode leftTree = mirrorTree(root.right);
        TreeNode rightTree = mirrorTree(root.left);
        root.left = leftTree;
        root.right = rightTree;
        return root;
    }
}

剑指 Offer 28. 对称的二叉树

题目描述

请实现一个函数，用来判断一棵二叉树是不是对称的。如果一棵二叉树和它的镜像一样，那么它是对称的。

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

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

    1
   / \\
  2   2
   \\   \\
   3    3

 

示例 1：

输入：root = [1,2,2,3,4,4,3]
输出：true
示例 2：

输入：root = [1,2,2,null,3,null,3]
输出：false

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/dui-cheng-de-er-cha-shu-lcof
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

思路

因为是对称的，所以从上到下依次判断左右子树是否相同，即left和right是否相同

class Solution {
    public boolean isSymmetric(TreeNode root) {
        if(root == null)
            return true;
        return isSame(root.left, root.right);
    }

    public boolean isSame(TreeNode A, TreeNode B){
    	//如果都为空，对称
        if(A == null && B == null)
            return true;
        //单个为空，不对称
        if(A == null || B == null)
            return false;
        //数值不同，不对称
        if(A.val != B.val)
            return false;
        //数值相同，看左右
        return isSame(A.left, B.right) && isSame(A.right, B.left);
    }
}

剑指 Offer 29. 顺时针打印矩阵

题目描述

输入一个矩阵，按照从外向里以顺时针的顺序依次打印出每一个数字。


示例 1：

输入：matrix = [[1,2,3],[4,5,6],[7,8,9]]
输出：[1,2,3,6,9,8,7,4,5]
示例 2：

输入：matrix = [[1,2,3,4],[5,6,7,8],[9,10,11,12]]
输出：[1,2,3,4,8,12,11,10,9,5,6,7]

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/shun-shi-zhen-da-yin-ju-zhen-lcof
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

思路

模拟这个过程，上右下左这样循环遍历，注意区间的开闭，如果行列较小值为奇数需要另外处理

class Solution {
    public int[] spiralOrder(int[][] matrix) {
        //模拟这个过程，循环处理就行了，循环n / 2次，注意循环时候区间的开闭
        int m = matrix.length;
        if(m == 0)
            return new int[]{};
        int n = matrix[0].length;

        int l = m < n ? m : n;
        //如果是奇数，需要在后面加一行
        boolean flag = false; 
        if(l % 2 == 1)
            flag = true;
        l = l / 2;
        int[] res = new int[m * n];

        int index = 0;
        for(int k = 0; k < l; k++){
            //所有区间都是左闭右开，上面的行
            for(int i = k; i < n - k - 1; i++){
                res[index++] = matrix[k][i];
            }
            //右边的列
            for(int i = k; i < m - k - 1; i++){
                res[index++] = matrix[i][n - k - 1];
            }
            //下面的行
            for(int i = n - k - 1; i > k; i--){
                res[index++] = matrix[m - k - 1][i];
            }
            //左边的列
            for(int i = m - k - 1; i > k; i--){
                res[index++] = matrix[i][k];
            }
        }
        //此时，最多只剩下一行或者一列了
        if(flag){
            for(int i = l; i <= m - l - 1; i++){
                for(int j = l; j <= n - l - 1; j++){
                    res[index++] = matrix[i][j];
                }
            }
        }
        return res;
    }
}

这里复制一个优雅的转圈遍历代码，几个月之前的，找不到是谁的了，不好意思，再学习一下

class Solution {
    //转圈遍历的优雅代码
    public List<Integer> spiralOrder(int[][] matrix) {
        LinkedList<Integer> result = new LinkedList<>();
        if(matrix==null||matrix.length==0) return result;
        int left = 0;   //左边
        int right = matrix[0].length - 1;   //右边
        int top = 0;    //上边
        int bottom = matrix.length - 1; //下边
        //总共的元素个数
        int numEle = matrix.length * matrix[0].length;
        while (numEle >= 1) {
            //最上面一行，从left到right
            for (int i = left; i <= right && numEle >= 1; i++) {
                result.add(matrix[top][i]);
                numEle--;
            }
            //然后top++
            top++;
            //最右边一列，从top到bottom
            for (int i = top; i <= bottom && numEle >= 1; i++) {
                result.add(matrix[i][right]);
                numEle--;
            }
            right--;
            //最下面一行，从right 到 left；注意到right已经减1了
            for (int i = right; i >= left && numEle >= 1; i--) {
                result.add(matrix[bottom][i]);
                numEle--;
            }
            bottom--;
            //最左面一列，bottom到top，注意到bottom也减1了
            for (int i = bottom; i >= top && numEle >= 1; i--) {
                result.add(matrix[i][left]);
                numEle--;
            }
            left++;
        }
        return result;
    }
}

还有官解中的这个直接模拟的方法，就是朝着一个方向走，如果到头了就换另一个方向，另外还需要一个矩阵来记录每个元素是否已经被访问了。感觉更不好想，而且实现起来也比较难。