判断T1树中是否有与T2树完全相同的子树

1. 描述

给定彼此独立的两棵二叉树，树上的节点值两两不同，判断T1树是否有T2树完全相同的子树
子树指一棵树的某个节点的全部后继节点
示例
输入
{1，2，3，4，5，6，7，#，8，9} ，{2,4,5,#,8,9}
输出
true

1. 思路

自己思考的同时也参考过网上的一些题解，但还是不想把逻辑过程弄得抽象(这么做的话，意图像是在“找规律”)，这不是我想要的，我还是更倾向于将程序的语义表达更加清晰。

简要的描述一下我的做法：我这里重点关注的是将数组形式的完美二叉树构建成树的数据结构->逻辑主要都集中在构建树的过程中了，子树的查询反而会变得更加简单扼要。

2. 我的题解

测试结果可以将根对象采用json形式输出出来，效果很明显

2.1 构建树

/**
 * @Author: weng
 * @Date: 2022/4/23
 * @Description: tree
 *
 * 构建完全二叉树
 */

public class CompleteBinaryTree {

    Node root;
    //节点对象数组是我后面加上的，这里可能看不出来作用，其实结合输入字符串的数组使用，效果拔群
    Node[] nodes;

    public CompleteBinaryTree(String[] seq){
        this.build(seq);
    }

    void build(String[] seq){

        //初始化所有节点
        this.nodes = new Node[seq.length];
        this.root = this.nodes[0] = new Node(seq[0]);
        for(int i=1;i<seq.length;i++){
            this.nodes[i] = new Node(seq[i]);
        }

        //节点、父节点
        Node node,pNode;

        //维系父子节点关系
        for(int i =1;i<seq.length;i++){
            node = this.nodes[i];
            //这里也是唯一需要用脑的地方——节点在数组、树中的位置关系
            pNode = this.nodes[(i-1)/2];
            pNode.child(node);
        }
    }
}

2.2 是否存在子树？

上面完事了，那这一块可以说没有烦恼了

import java.util.Scanner;

/**
 * @Author: weng
 * @Date: 2022/4/23
 * @Description: tree
 */

public class Main {

    //父、子树的数组形式
    static String[] p,c;

    /**
     * 
function:
     * 
tip:
     *
     * @param: []
     * @return: void
     * @author: weng
     * @date: 2022/4/23 21:08
     *
     * 测试输入：
     *  {1,2,3,4,5,6,7,#,8,9} ,{2,4,5,#,8,9}
     */
    static void init(){
        Scanner scanner = new Scanner(System.in);
        String s = scanner.nextLine();
        int idx_bgn_1 = s.indexOf("{")+1;
        int idx_end_1 = s.indexOf("}");
        int idx_bgn_2 = s.lastIndexOf("{")+1;
        int idx_end_2 = s.lastIndexOf("}");
        p = s.substring(idx_bgn_1,idx_end_1).split("[,]");
        c = s.substring(idx_bgn_2,idx_end_2).split("[,]");
        scanner.close();
    }

    static boolean isSub(Node pNode,Node cNode){
        if(cNode == null){
            return true;
        }
        else if(!pNode.value.equals(cNode.value)){
            return false;
        }else{
            return isSub(pNode.left,cNode.left) && isSub(pNode.right,cNode.right);
        }
    }

    public static void main(String[] args) {
        init();
        String cRootValue = c[0];
        for(int i=0;i<p.length;i++){
            //找到父树中子树根节点的索引
            if(!cRootValue.equals(p[i])){
                continue;
            }
            Node pNode = new CompleteBinaryTree(p).nodes[i];
            Node cNode = new CompleteBinaryTree(c).root;
            System.out.println(isSub(pNode,cNode));
            break;
        }
    }
}

3. 另一种做法

public class SubTree6 {

    static String[] ct,st;

    static void init(){
        ct = "1,2,3,4,5,6,7,#,8,9".split("[,]");
        st = "2,4,5,#,8,9".split("[,]");
    }

    static boolean traverse(int cIdx,int sIdx){
        if(sIdx >= st.length){
            return true;
        }
        else if(cIdx >= ct.length){
            return false;
        }
        int cChildIdx = obtainChildIdx(cIdx);
        int sChildIdx = obtainChildIdx(sIdx);
        return ct[cIdx].equals(st[sIdx]) && traverse(cChildIdx,sChildIdx) && traverse(cChildIdx+1,sChildIdx+1);
    }

    static int obtainChildIdx(int pIdx){
        return 2*pIdx+1;
    }

    public static void main(String[] args) {
        init();
        String st0 = st[0];
        for(int i =0;i<ct.length;i++){
            if(!st0.equals(ct[i])){
                continue;
            }
            System.out.println(traverse(i,0));
            return;
        }
        System.out.println(false);
    }
}