在Java中的二叉搜索树中找到节点？

Question

我正在尝试编写一种方法，该方法返回二进制搜索树中目标int的深度。 目前，它适用于一些较小的树木，但并非总是如此。 有人看到我可能出问题了吗？

  static int count=1;
            public static int findDepth(TreeNode<Integer> root, int target)
            // pre: 0 or more elements in the tree, integer to search for
            // post: return depth of target if found, -1 otherwise
            {
                count++;
                if (root!=null)
                {
                    if (root.getValue()<target)
                    {
                        if (root.getValue()==target)
                        {System.out.println(count); 
                        return count;}
                        else

                        {findDepth(root.getLeft(), target);
                        count--;
                        findDepth(root.getRight(), target);
                        }
                    }
                    else if (root.getValue()>target)
                    {
                        if (root.getValue()==target)
                        {System.out.println(count); 
                        return count;}
                        else

                        {findDepth(root.getLeft(), target);
                        count--;
                        findDepth(root.getRight(), target);
                        }
                    }
                    else if (root.getValue()==target)
                        return 1;
                    else
                        return -1;
                }
                return count;
            }

Answer 1

有一些错误。

它永远不会进入这种情况：

if (root.getValue()<target)
{
   if (root.getValue()==target)
       {System.out.println(count); 
       return count;}

而且它永远不会进入这种情况：

else if (root.getValue()>target)
{
    if (root.getValue()==target)
        {System.out.println(count); 
        return count;}

最大的问题是您要保持全局静态计数，并递归地遍历左右路径。

首先，对于BST，无需同时左右移动。

其次，最好通过参数传递计数，而不要保留全局变量。

我将发布此工作示例供您参考，而不是修改您的代码：

public class Main
{
  public static void main(String[] args)
  {
    BinaryTree tree = new BinaryTree();

    tree.add(20);
    tree.add(10);
    tree.add(30);
    tree.add(15);
    tree.add(25);
    tree.add(5);
    tree.add(35);
    tree.add(1);
    tree.add(6);
    tree.add(14);
    tree.add(16);
    tree.add(24);
    tree.add(26);
    tree.add(34);
    tree.add(36);


    int level = tree.getLevel(6);

    System.out.println(level);

  }
}

public class TreeNode
{
  int data;
  TreeNode left;
  TreeNode right;

  public TreeNode(int d){
    data = d;
    left = null;
    right = null;
  }

}

public class BinaryTree
{
  TreeNode root;

  public BinaryTree(){
    root = null;
  }

  public int getLevel(int val) {
    if (root == null) return 0;
    return getLevelHelper(root, val, 0);

  }

  public int getLevelHelper(TreeNode node, int val, int level){


    int retVal = -1;

    if (node.data == val){
      return level;
    }
    if (val < node.data && node.left != null){
      retVal = getLevelHelper(node.left, val, level + 1);
    }
    else if (val > node.data && node.right != null){
      retVal = getLevelHelper(node.right, val, level + 1);
    }

    return retVal;
  }




  public boolean add(int newData){
    if (root == null){
      root = new TreeNode(newData);
      return true;
    }
    else{
      TreeNode curr = root;
      while (true){
        if (curr.data == newData){
          return false;
        }
        else if (curr.data > newData){
          if (curr.left == null){
            curr.left = new TreeNode(newData);
            return true;
          }
          else{
            curr = curr.left;
          }


        }
        else{
          if (curr.right == null){
            curr.right = new TreeNode(newData);
            return true;
          }
          else{
            curr = curr.right;
          }
        }
      }
    }

  }
}