Question

vvI有一个只能在Integer上运行的BST，一切都很好，直到我试图将其改为泛型。

public class Tree<T extends Comparable<T>> {
    Node root = null;      

    private class Node {
        T key;
        Node left, right, parent = null;
        Node(T key) {
            this.key = key;
        }
    }  


    public void insert(T key) {       
        if (root == null)
            root = new Node(key);
        else {
            Node actual = root;
            Node parent = null;
            while(actual != null) {
                parent = actual;               
                actual = (actual.key.compareTo(key) > 0) ? actual.left : actual.right;                 
            }
            if (parent.key.compareTo(key) > 0) {
                parent.left = new Node(key);
                parent.left.parent = parent;
            }
            if (parent.key.compareTo(key) <= 0 ) {
                parent.right = new Node(key);
                parent.right.parent = parent;
            }
        }              
    }              
/**********************     end BSTInsert       *******************************/


    public Node search(T key)  {
        Node actual = root;
        while (actual != null && actual.key != key) {
            actual = (actual.key.compareTo(key) > 0) ? actual.left : actual.right;
        }
        if (actual == null) {
            System.out.println("dont exist");
            return null;
        }
        return actual;            
    }

    public void inOrder(Node node) { 
        if (node != null) {
            inOrder(node.left);
            System.out.print(node.key + ", ");
            inOrder(node.right);
        }
    }
}

这是代码的一小部分。函数搜索有空指针以及我的函数的其余部分（未列出）函数搜索给出空指针，不知道为什么。似乎函数insert和inOrder工作正常

我怀疑问题在于我对java中泛型的理解，因为更改前的代码在整数上工作正常。

提前致谢。

@edit 你是对的。 BST树很好。问题出在这个代码中：

   public class TreeTest {
      public static void main(String args[]){
        Tree<String> tree = new Tree<String>();
        tree.insert("a");
        tree.insert("b");
        tree.insert("c");   
        tree.inOrder(tree.root);    
        tree.search("b");                      //everything is fine


        Scanner read = new Scanner(System.in);
        String txt;

        txt = read.nextLine();    //write b
        tree.search(txt);      //there is no b in tree
      }
    }

Answer 1

首先，使用递归更容易理解。

其次，如果你没有告诉我任何问题，我就无法看到你的错误。

我已经在一个完美运行的BST算法中找到了自己的发现：

protected Node<E> find(E element, Node<E> node) {
        if (node == null) {
            return null;
        }
        if (node.getElement() == element) {
            return node;
        }
        if (node.getElement().compareTo(element) > 0) {
            return find(element, node.getLeft());
        } else {
            return find(element, node.getRight());
        }
    }

如果您向我提供更多信息，我可以提供更多服务。

泛型BST空指针

1 个答案: