1、二叉樹節點類

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

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

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

    
 
//----------------------------

    public int getVal() {
        return val;
    }

    public void setVal(int val) {
        this.val = val;
    }

    public TreeNode getLeft() {
        return left;
    }

    public void setLeft(TreeNode left) {
        this.left = left;
    }

    public TreeNode getRight() {
        
 
return right;
    }

    public void setRight(TreeNode right) {
        this.right = right;
    }
}

2、二叉樹打印類

public class PrintTree {
    public void printNode(TreeNode node){
        System.out.print(node.getVal());
    }

    //先序遍歷
    public void theFirstTraversal(TreeNode root) {
        printNode(root);
        
 
if (root.getLeft() != null) {  //使用遞歸進行遍歷左孩子  
            theFirstTraversal(root.getLeft());
        }
        if (root.getRight() != null) {  //遞歸遍歷右孩子  
            theFirstTraversal(root.getRight());
        }
    }

    //中序遍歷
    public void theInOrderTraversal(TreeNode root) {
        if (root.getLeft() != null) {
            theInOrderTraversal(root.getLeft());
        }
        printNode(root);
        if (root.getRight() != null) {
            theInOrderTraversal(root.getRight());
        }
    }

    //後序遍歷
    public void thePostOrderTraversal(TreeNode root) {
        if (root.getLeft() != null) {
            thePostOrderTraversal(root.getLeft());
        }
        if(root.getRight() != null) {
            thePostOrderTraversal(root.getRight());
        }
        printNode(root);
    }

}

3、判斷二叉樹是否包含另一棵樹的類

public class HasSubtree {
    public boolean hasSubtree(TreeNode root1, TreeNode root2) {

        boolean result = false;
        //當Tree1和Tree2都不為零的時候，才進行比較。否則直接返回false
        if (root2 != null && root1 != null) {
            //如果找到了對應Tree2的根節點的點
            if (root1.val == root2.val) {
                //以這個根節點為為起點判斷是否包含Tree2
                result = doesTree1HaveTree2(root1, root2);
            }
            //如果找不到，那麽就再去root的左葉子當作起點，去判斷時候包含Tree2
            if (!result) {
                result = hasSubtree(root1.left, root2);
            }

            //如果還找不到，那麽就再去root的右兒子當作起點，去判斷時候包含Tree2
            if (!result) {
                result = hasSubtree(root1.right, root2);
            }
        }
        //返回結果
        return result;
    }

    public static boolean doesTree1HaveTree2(TreeNode node1, TreeNode node2) {
        //如果Tree2已經遍歷完了都能對應的上，返回true
        if (node2 == null) {
            return true;
        }
        //如果Tree2還沒有遍歷完，Tree1卻遍歷完了。返回false
        if (node1 == null) {
            return false;
        }
        //如果其中有一個點沒有對應上，返回false
        if (node1.val != node2.val) {
            return false;
        }

        //如果根節點對應的上，那麽就分別去子節點裏面匹配
        return doesTree1HaveTree2(node1.left, node2.left) && doesTree1HaveTree2(node1.right, node2.right);
    }
}

4、測試類

public class TestMain {
    public static void main(String[] args) {
        //創建二叉樹tree1
        TreeNode root1=new TreeNode(0);
        TreeNode node11=new TreeNode(1);
        TreeNode node12=new TreeNode(2);
        TreeNode node13=new TreeNode(3);
        TreeNode node14=new TreeNode(4);
        TreeNode node15=new TreeNode(5);
        TreeNode node16=new TreeNode(6);

        root1.setLeft(node11);
        root1.setRight(node12);
        node11.setLeft(node13);
        node11.setRight(node14);
        node12.setLeft(node15);
        node12.setRight(node16);

        //采用前序遍歷方式打印二叉樹
        PrintTree p=new PrintTree();
        p.theFirstTraversal(root1);
        System.out.println();

        //創建二叉樹tree2
        TreeNode root2=new TreeNode(1);
        TreeNode node21=new TreeNode(3);
        TreeNode node22=new TreeNode(4);

        root2.setLeft(node21);
        root2.setRight(node22);

        //采用前序遍歷方式打印二叉樹
        PrintTree p2=new PrintTree();
        p2.theFirstTraversal(root2);
        System.out.println();

        //判斷tree2是否為tree1的子樹
        HasSubtree h=new HasSubtree();
        Boolean b=h.hasSubtree(root1,root2);
        System.out.println("是否包含："+b);

    }
}

二叉樹的創建、遍歷、判斷子二叉樹