Question

我的问题非常简单。我正在使用Java来执行二阶搜索树按顺序遍历（递归），并且我需要以某种方式比较我遇到的最后一个节点和当前节点之间的节点值，以查看整个树是否是二叉搜索树或不。我使用了如下签名：

private void helper(List<TreeNode> list,TreeNode p,TreeNode q)

在这种方法中，p我的意思是我正在处理的当前节点，q我的意思是我处理的最后一个节点。我在编写方法时遇到了麻烦。所以请分享你的知识。

Answer 1

我认为您不需要TreeNodes列表作为此辅助方法的参数，因为当您传入根节点时，它将包含所有其他TreeNode。这是一种确定二叉树是否正确顺序的方法。（首先将根节点传递给公共帮助器方法）：

public boolean helper(TreeNode root)
    {
        if (root.getLeftNode() == null)
        {
            if (root.getRightNode() == null)
                return true;
            else return helper(root.getRightNode(), root);
        }
        //if everything branching from leftNode is in order
        else if(helper(root.getLeftNode(), root))
        {
            if (root.getRightNode() != null)
                return helper(root.getRightNode(), root);
            else return true;
        }
        else return false;
    }

    private boolean helper(TreeNode currentNode, TreeNode previousNode)
    {
        //Test leftNode
        if (currentNode == previousNode.getLeftNode())
        {
            if (currentNode.getData() > previousNode.getData()) return false;
            else
            {
                if (currentNode.getLeftNode() == null)
                {
                    if (currentNode.getRightNode() == null)
                        return true;
                    else return helper(currentNode.getRightNode(), currentNode);
                }
                //if everything branching from leftNode is in order
                else if(helper(currentNode.getLeftNode(), currentNode))
                {
                    if (currentNode.getRightNode() != null)
                        return helper(currentNode.getRightNode(), currentNode);
                    else return true;
                }
                else return false;
            }
        }
        //Test rightNode
        else
        {
            if (currentNode.getData() < previousNode.getData()) return false;
            else
            {
                if (currentNode.getLeftNode() == null)
                {
                    if (currentNode.getRightNode() == null)
                        return true;
                    else return helper(currentNode.getRightNode(), currentNode);
                }
                //if everything branching from leftNode is in order
                else if(helper(currentNode.getLeftNode(), currentNode))
                {
                    if (currentNode.getRightNode() != null)
                        return helper(currentNode.getRightNode(), currentNode);
                    else return true;
                }
                else return false;
            }
        }
    }

假设您正在使用与此类似的TreeNode类：

public class TreeNode
{
    private TreeNode leftNode;
    private TreeNode rightNode;
    private int data;

    public TreeNode(int data, TreeNode leftNode, TreeNode rightNode)
    {
        this.data = data;
        this.leftNode = leftNode;
        this.rightNode = rightNode;
    }

    public TreeNode getLeftNode()
    {
        return leftNode;
    }
    public TreeNode getRightNode()
    {
        return rightNode;
    }
    public int getData()
    {
        return data;
    }
}

我确信这可以更好，更有效地编写，但我希望这至少让你走上正确的轨道。

Answer 2

为了检查Tree是BST还是Not，我们可以进行inorder遍历。在进行按顺序遍历时，我们可以跟踪以前访问过的节点。如果当前访问的节点的值小于先前的值，则树不是BST。

public class IsBstTest {

private static TreeNode prevNode;  

public static void main(String[] args) {
    TreeNode root = new TreeNode(4);
    root.left = new TreeNode(2);
    root.right = new TreeNode(5);
    root.right.left = new TreeNode(6);
    root.right.right = new TreeNode(7);

    if (isBst(root))
        System.out.println("Is BST");
    else
        System.out.println("Not a BST");
}

public static Boolean isBst(TreeNode root) {
    if (root != null) {
        if (!isBst(root.left)) {
            return false;
        }
        if (prevNode != null && root.value <= prevNode.value) {
            return false;
        }
        prevNode = root;
        return isBst(root.right);
    }
    return true;
}

}

TreeNode是：

public class TreeNode {

public int value;

public TreeNode left;

public TreeNode right;

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

如何在二进制搜索树中按顺序跟踪先前节点？

2 个答案: