树的子结构、二叉树镜像

树的子结构题目描述

输入两棵二叉树A，B，判断B是不是A的子结构。（ps：我们约定空树不是任意一个树的子结构）

考察递归和树

答案参考：https://www.cnblogs.com/lishanlei/p/10707732.html

先上代码

public class DailyTest {

    public static void main(String[] args) {
        System.out.println(666);
    }
    public boolean HasSubtree(TreeNode root1,TreeNode root2) {
        boolean result = false;
        if (root1!=null&&root2!=null) {
            if (root1.val == root2.val) {
                //以这个根节点为起点判断是否包含root2
                result = DoesTreeHaveTree2(root1,root2);
            }
            if (!result) {
                result = HasSubtree(root1.left,root2);
            }
            if (!result) {
                result = HasSubtree(root1.right,root2);
            }
        }
        return result;
    }

    public boolean DoesTreeHaveTree2(TreeNode node1, TreeNode node2) {
        if (node2 == null) {
            return true;
        }
        if (node1==null) {
            return false;
        }
        if (node1.val!=node2.val) {
            return false;
        }
        return DoesTreeHaveTree2(node1.left,node2.left) && DoesTreeHaveTree2(node1.right,node2.right);
    }
}

class TreeNode {
    int val = 0;
    TreeNode left = null;
    TreeNode right = null;

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

这道题目的解题思路是：我们先判断从A树的根节点开始，B树是否是其子结构；如果不是，那么看从A树的根节点的左子节点开始，B树是否是其子结构；如果不是，那么看从A树的根节点的右子节点开始，B树是否是其子结构；从思路分析我们可以看出使用递归。

 

二叉树镜像题目描述

操作给定的二叉树，将其变换为源二叉树的镜像。

import java.util.*;

/*
 * public class TreeNode {
 *   int val = 0;
 *   TreeNode left = null;
 *   TreeNode right = null;
 *   public TreeNode(int val) {
 *     this.val = val;
 *   }
 * }
 */

public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param pRoot TreeNode类 
     * @return TreeNode类
     */
    public TreeNode Mirror (TreeNode pRoot) {
        // write code here
        if (pRoot==null) {
            return pRoot;
        }
        if (pRoot.left != null || pRoot.right != null) {
            TreeNode treeNode = pRoot.left;
            pRoot.left = pRoot.right;
            pRoot.right = treeNode;
            Mirror(pRoot.left);
            Mirror(pRoot.right);
        }
        return pRoot;
    }
}

还有一种就是采用基于栈的DFS来遍历

参考：https://blog.csdn.net/dawn_after_dark/article/details/80850422

    /**
     * 非递归实现, 借助栈或者列表遍历树中每一个非叶子节点
     * 交换其左右子树即可
     * @param root
     */
    public static void Mirror2(TreeNode root) {
        if(root == null) {
            return;
        }
        Stack<TreeNode> stack = new Stack<>();
        stack.push(root);
        while(!stack.isEmpty()) {
            TreeNode node = stack.pop();
            TreeNode temp = node.left;
            node.left = node.right;
            node.right = temp;
            if(node.left != null) {
                stack.push(node.left);
            }
            if(node.right != null) {
                stack.push(node.right);
            }
        }
    }