Java 检查二叉树中的所有值是否低于其他二叉树中的所有值

我有一个函数-lessThanTree（BinNode t1，int-value），如果值小于t1中的所有值，它将返回true

现在我有了一个赋值来使用这个函数并编写另一个函数，该函数接收两个二叉树（t1，t2），如果t1中的所有值都小于t2中的所有值，则返回true

我编写了以下递归代码：

public static boolean treeLessThanTree(BinNode<Integer> t1, BinNode<Integer> t2) {
        if (t1 == null)
            return true;
        return lessThanTree(t2, t1.getValue()) && treeLessThanTree(t1.getLeft(), t2)
                && treeLessThanTree(t1.getRight(), t2);
    }

publicstaticboolearntreelessthantree（BinNode t1，BinNode t2）{
如果（t1==null）
返回true；
返回lessThanTree（t2，t1.getValue（））和&treeLessThanTree（t1.getLeft（），t2）
&&treeLessThanTree（t1.getRight（），t2）；
}

---

这行得通吗？

它应该行得通，但是如果这两棵树是二进制搜索树，它就不必要地调用

lessThanTree（t2，t1.getValue（））

和

treeLessThanTree（t1.getLeft（），t2）

返回

treeLessThanTree（t1.getRight（），t2）

（只要

t1.getRight（）

不为空）就足够了，因为

t1

的最大元素总是位于右子树中（或者根中，如果根没有右子树）

因此，更有效的解决方案是：

public static boolean treeLessThanTree(BinNode<Integer> t1, BinNode<Integer> t2) 
{
    if (t1 == null)
        return true;
    else if (t1.getRight() != null)
        return treeLessThanTree(t1.getRight(), t2);
    else 
        return lessThanTree(t2, t1.getValue());
}

publicstaticboolearntreelessthantree（BinNode t1，BinNode t2）
{
如果（t1==null）
返回true；
else if（t1.getRight（）！=null）
返回treeLessThanTree（t1.getRight（），t2）；
其他的
返回lessThanTree（t2，t1.getValue（））；
}

公共类二进制树{ 私有节点根

private class Node{
    private Node left;
    private Node right;
    private Integer data;
    public Node(Integer data){
        this.left = null;
        this.right = null;
        this.data = data;
    }
}

public BinaryTree(){
    root = null;
}

public void buildTree(Node node,Integer data){
    if(root == null){
        root = new Node(data);
    }else{
        if(data < node.data){
            if(node.left == null){
                node.left = new Node(data);
            }else{
                buildTree(node.left,data);
            }
        }else{
            if(node.right == null){
                node.right = new Node(data);
            }else{
                buildTree(node.right,data);
            }
        }
    }
}


public void preOrder(Node node){  
    if(node != null){  
        System.out.println(node.data);  
        preOrder(node.left);  
        preOrder(node.right);  
    }  
}  


public void inOrder(Node node){  
    if(node != null){  
        inOrder(node.left);  
        System.out.println(node.data);  
        inOrder(node.right);  
    }  
}  


public void postOrder(Node node){  
    if(node != null){  
        postOrder(node.left);  
        postOrder(node.right);  
        System.out.println(node.data);  
    }  
}  

私有类节点{
私有节点左；
私有节点权；
私有整数数据；
公共节点（整数数据）{
this.left=null；
this.right=null；
这个数据=数据；
}
}
公共二叉树（）{
root=null；
}
公共void构建树（节点，整数数据）{
if（root==null）{
根=新节点（数据）；
}否则{
if（数据<节点数据）{
if（node.left==null）{
node.left=新节点（数据）；
}否则{
构建树（node.left，data）；
}
}否则{
if（node.right==null）{
node.right=新节点（数据）；
}否则{
构建树（node.right，data）；
}
}
}
}
公共无效预订单（节点）{
如果（node！=null）{
System.out.println（节点数据）；
前序（node.left）；
前序（node.right）；
}  
}  
公共无效序（节点）{
如果（node！=null）{
顺序（node.left）；
System.out.println（节点数据）；
顺序（node.right）；
}  
}  
public void postOrder（节点）{
如果（node！=null）{
postOrder（节点左）；
postOrder（node.right）；
System.out.println（节点数据）；
}  
}  

---

}

要确定t1中的所有项目是否都小于t2中的所有节点，您需要做的就是确保t1中最大的项目小于t2中最小的项目

如果树是二元搜索树，那么查找最小的项是一个简单的问题，即从根遍历到最低、最左边的项。通过从根遍历到最低、最右边的项，可以得到最大值

如果它们不是二进制搜索树，那么您必须遍历整个树以查找最小和最大的项

---

如果树是平衡的二叉搜索树，那么复杂性是O（log（t1.length）+log（t2.length）），否则，最坏的情况是O（t1.length+t2.length）。

你试过运行这个吗？看起来它可以工作。@user7我在创建两个二叉树时遇到一些问题。。在学校，我们通常编写代码，老师会帮我们检查。OP没有说这是BSTIf，如果是这种情况，我们可以遍历到最右边的节点，然后只检查它。Toda！我忘了最大的元素总是在正确的子元素中-tree@user7哎呀，不知什么原因，我认为它是一个二元搜索树。@DAVIDBALAS1只有当树是二元搜索树时才正确，你在问题中没有提到。如果它们是一般的二叉树，我的答案是错误的。请让我知道。