Question

我有一个函数 - lessThanTree（BinNode t1，int value），如果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);
    }

这会有用吗？

Answer 1

它应该可以工作，但是如果这两棵树是二叉搜索树，则会不必要地调用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());
}

Answer 2

public class BinaryTree { 私有节点根;

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);  
    }  
}

}

Answer 3

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

如果树是二叉搜索树，那么找到最小的项是一个简单的事情，从根到最低，最左边的项。并且通过从根到最低，最右边的项目获得最大值。

如果它们不是二叉搜索树，那么你必须遍历整个树以找到最小和最大的项目。

如果树是平衡二元搜索树，则复杂度为O（log（t1.length）+ log（t2.length））否则，最坏情况为O（t1.length + t2.length）。

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

3 个答案: