Question

我在二叉搜索树中有以下用于插入和删除的java代码。但这是我第一次使用java，并希望在我可以使用Google概念之前寻求某些方面的帮助。

public class BinarySearchTree {
    public static  Node root;
    public BinarySearchTree(){
        this.root = null;
    }

    public boolean find(int id){
        Node current = root;
        while(current!=null){
            if(current.data==id){
                return true;
            }else if(current.data>id){
                current = current.left;
            }else{
                current = current.right;
            }
        }
        return false;
    }

    public boolean delete(int id){
        Node parent = root;
        Node current = root;
        boolean isLeftChild = false;
        while(current.data!=id){
            parent = current;
            if(current.data>id){
                isLeftChild = true;
                current = current.left;
            }else{
                isLeftChild = false;
                current = current.right;
            }
            if(current ==null){
                return false;
            }
        }
        //if i am here that means we have found the node
        //Case 1: if node to be deleted has no children
        if(current.left==null && current.right==null){
            if(current==root){
                root = null;
            }
            if(isLeftChild ==true){
                parent.left = null;
            }else{
                parent.right = null;
            }
        }
        //Case 2 : if node to be deleted has only one child
        else if(current.right==null){
            if(current==root){
                root = current.left;
            }else if(isLeftChild){
                parent.left = current.left;
            }else{
                parent.right = current.left;
            }
        }
        else if(current.left==null){
            if(current==root){
                root = current.right;
            }else if(isLeftChild){
                parent.left = current.right;
            }else{
                parent.right = current.right;
            }
        }else if(current.left!=null && current.right!=null){

            //now we have found the minimum element in the right sub tree
            Node successor   = getSuccessor(current);
            if(current==root){
                root = successor;
            }else if(isLeftChild){
                parent.left = successor;
            }else{
                parent.right = successor;
            }           
            successor.left = current.left;
        }       
        return true;        
    }

    public Node getSuccessor(Node deleleNode){
        Node successsor =null;
        Node successsorParent =null;
        Node current = deleleNode.right;
        while(current!=null){
            successsorParent = successsor;
            successsor = current;
            current = current.left;
        }
        //check if successor has the right child, it cannot have left child for sure
        // if it does have the right child, add it to the left of successorParent.
//      successsorParent
        if(successsor!=deleleNode.right){
            successsorParent.left = successsor.right;
            successsor.right = deleleNode.right;
        }
        return successsor;
    }

    public void insert(int id){
        Node newNode = new Node(id);
        if(root==null){
            root = newNode;
            return;
        }
        Node current = root;
        Node parent = null;
        while(true){
            parent = current;
            if(id<current.data){                
                current = current.left;
                if(current==null){
                    parent.left = newNode;
                    return;
                }
            }else{
                current = current.right;
                if(current==null){
                    parent.right = newNode;
                    return;
                }
            }
        }
    }

    public void display(Node root){
        if(root!=null){
            display(root.left);
            System.out.print(" " + root.data);
            display(root.right);
        }
    }

    public static void main(String arg[]){
        BinarySearchTree b = new BinarySearchTree();
        b.insert(3);b.insert(8);
        b.insert(1);b.insert(4);b.insert(6);b.insert(2);b.insert(10);b.insert(9);
        b.insert(20);b.insert(25);b.insert(15);b.insert(16);
        System.out.println("Original Tree : ");
        b.display(b.root);      
        System.out.println("");
        System.out.println("Check whether Node with value 4 exists : " + b.find(4));
        System.out.println("Delete Node with no children (2) : " + b.delete(2));        
        b.display(root);
        System.out.println("\n Delete Node with one child (4) : " + b.delete(4));       
        b.display(root);
        System.out.println("\n Delete Node with Two children (10) : " + b.delete(10));      
        b.display(root);
    }
}

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

我有两个问题如下

拥有root，（这是一个静态变量）是否有意义在构造函数内初始化为null？这么想，因为，无论创建多少个对象，都只有root（因为root 是静态的，所以，为什么有必要在构造函数内声明每次创建新对象时都会调用它。
为什么构造函数是必需的？我们不能宣布/初始化创建时的所有变量，如下所示

public class BinarySearchTree {
    public static  Node root = null;
    ... 
}

Answer 1

拥有static成员变量意味着它属于类本身，而不是特定成员。换句话说，它在所有实例之间共享。现在我们明白了，很清楚为什么拥有static根成员是一个有问题的设计 - 它不允许你有两个断开连接的树，因为它们都共享相同的根节点。

如果确实如此，root肯定应该内联（private static Node root = null;）而不是构造函数初始化。在构造函数中使用此逻辑意味着每次创建新树 all 时，现有树将失去其根。

Answer 2

必须仔细考虑使用静态成员，因为正如您所说，BinarySearchTree创建的所有实例始终存在相同的实例。因此，在您的代码中，root每次创建新实例时都会重置为null。因此，不要这样做。
您实际上可以像您建议的那样初始化您定义它的root。

但是，通过删除root关键字或将树的数据结构与搜索算法分开，使BinarySearchTree成为static的成员是更好的做法。然后，您将root元素作为参数传递给方法。

从数据的角度考虑整个事物 - 您要搜索的树，由它的根节点表示 - 以及对数据进行操作的服务。该服务不应该以紧密的方式与数据绑定：您应该能够使用相同的服务来处理不同的输入数据集。

是初始化静态变量所需的构造函数？

2 个答案: