Java二进制树：如何在insert方法中平衡树？

我正在尝试平衡二叉搜索树，我知道它为什么不起作用，但我不知道如何修复它。 我直接在insert方法中平衡。 我用斜线标出了平衡的位置。 像这样，代码不起作用，我得到一个例外：

Exception in thread "main" java.lang.NullPointerException
at Baueme.Treee.insert(Treee.java:54)
at Baueme.Treee.insert(Treee.java:18)
at Baueme.TestTheTree.main(TestTheTree.java:12)

当我插入时，没有平衡，一切都很好

public class Node {

public Node left, right, parent;
public int value;

public Node (Node parent, int i) {
    this.parent = parent;
    this.value = i;
}

public int height() {
    int l = 0;
    int r = 0;

    if (this.left  != null) {
        l = this.left.height() +1;
    }

    if (this.right  != null) {
        r = this.right.height() +1;
    }

    return Math.max(l,r);
}   
}
public class Tree {
Node root;

public Tree() {
    root = null;
}

public void insert (int value) {

    if (root == null) {
        root = new Node(null, value);
    }
    else {
        insert(root, value);
    }
}

private void insert (Node parent, int value) {

    if (parent.value >= value) {

        if (parent.left == null) {
            parent.left = new Node (parent, value);
        }
        else {
            insert(parent.left, value);

       /////////////////////////    
            if ( parent.left.height() - parent.right.height() == 2) {

                if (value - parent.left.value < 0) {
                    parent = rotateWithLeftChild(parent);
                }
                else {
                    parent = doubleRotateWithRightChild(parent);
                }
            }           
      /////////////////////////
        }
    }

    else {

        if (parent.right == null) {
            parent.right = new Node (parent, value);
        }
        else {
            insert(parent.right, value);
      /////////////////////////
            if ( parent.left.height() - parent.right.height() == -2) {

                if (value - parent.right.value > 0) {
                    parent = rotateWithRightChild(parent);
                }
                else {
                    parent = doubleRotateWithLeftChild(parent);
                }
            }
     /////////////////////////
    }
     }
     }
    public int quantity() {

if (root == null) {
    return 0;
}
else {
    return 1 + quantity(root.left) + quantity(root.right);          
}
 }
public int quantity (Node parent) {

if (parent == null) {
    return 0;
}
else {
    return 1 + quantity(parent.left) + quantity(parent.right);
}
}
public int height () {

int l = 0;
int r = 0;

if ( root.left != null) {
    l = height(root.left) + 1;
}

if (root.right != null) {
    r = height(root.right) +1;
}

return (Math.max(l,r));
}
private int height (Node parent) {

int l = 0;
int r = 0;

if ( parent.left != null) {
    l = height(parent.left) + 1;
}

if (parent.right != null)   {
    r = height(parent.right) +1;
}

return (Math.max(l,r));
}
public String toString () {

    if (root == null) {
        return "empty tree";
    }
    else {
        return toString(root.left) + " ; " + root.value + " ; " +  toString(root.right);
    }
}


private String toString (Node parent) {

    if (parent == null) {
        return "";
    }
    else {
        return toString(parent.left) + " ; " + parent.value
        + " ; " + toString(parent.right);
    }
}
private String toString (Node parent) {

if (parent == null) {
    return "";
}
else {
    return toString(parent.left) + " ; " + parent.value
    + " ; " +     toString(parent.right);
  }
 }
private Node rotateWithLeftChild (Node k2) {
Node k1 = k2.left;
k2.left = k1.right;
k1.right = k2;

return k1;
}
private Node rotateWithRightChild (Node k1) {
Node k2 = k1.right;
k1.right = k2.left;
k2.left = k1;

return k2;
}
private Node doubleRotateWithRightChild (Node k3) {
k3.left = rotateWithRightChild(k3.left);

return rotateWithLeftChild(k3);
}
private Node doubleRotateWithLeftChild (Node k1) {
k1.right = rotateWithLeftChild(k1.right);
return rotateWithRightChild(k1);
}

}
public class TestTheTree {
public static void main(String[] args) {


    Treee temp = new Treee();

    temp.insert(10);
    temp.insert(20);
    temp.insert(30);


    System.out.println(temp.toString());


  }
  }

公共类节点{
公共节点左、右、父节点；
公共价值观；
公共节点（节点父节点，int i）{
this.parent=parent；
该值=i；
}
公共整数高度（）{
int l=0；
int r=0；
if（this.left！=null）{
l=此.左.高（）+1；
}
如果（this.right！=null）{
r=此.右.高（）+1；
}
返回Math.max（l，r）；
}   
}
公共类树{
节根；
公树（）{
root=null；
}
公共空白插入（int值）{
if（root==null）{
根=新节点（空，值）；
}
否则{
插入（根，值）；
}
}
专用void插入（节点父节点，int值）{
如果（parent.value>=值）{
if（parent.left==null）{
parent.left=新节点（父节点，值）；
}
否则{
插入（parent.left，value）；
/////////////////////////    
if（parent.left.height（）-parent.right.height（）=2）{
if（值-parent.left.value<0）{
父项=rotateWithLeftChild（父项）；
}
否则{
父项=双旋转第三个子项（父项）；
}
}           
/////////////////////////
}
}
否则{
if（parent.right==null）{
parent.right=新节点（父节点，值）；
}
否则{
插入（parent.right，value）；
/////////////////////////
if（parent.left.height（）-parent.right.height（）=-2）{
如果（值-parent.right.value>0）{
父项=第三个旋转子项（父项）；
}
否则{
父项=双旋转子项（父项）；
}
}
/////////////////////////
}
}
}
公共整数数量（）{
if（root==null）{
返回0；
}
否则{
返回1+数量（左根）+数量（右根）；
}
}
公共整数数量（节点父节点）{
如果（父项==null）{
返回0；
}
否则{
返回1+数量（父.左）+数量（父.右）；
}
}
公共整数高度（）{
int l=0；
int r=0；
if（root.left！=null）{
l=高度（根部左侧）+1；
}
if（root.right！=null）{
r=高度（根部右侧）+1；
}
返回值（数学最大值（l，r））；
}
专用整数高度（节点父节点）{
int l=0；
int r=0；
if（parent.left！=null）{
l=高度（左上角）+1；
}
if（parent.right！=null）{
r=高度（父级右侧）+1；
}
返回值（数学最大值（l，r））；
}
公共字符串toString（）{
if（root==null）{
返回“空树”；
}
否则{
返回到字符串（root.left）+“；”+root.value+”；“+toString（root.right）；
}
}
私有字符串到字符串（节点父级）{
如果（父项==null）{
返回“”；
}
否则{
返回到字符串（parent.left）+“；”+parent.value
+“；”+toString（父项右）；
}
}
私有字符串到字符串（节点父级）{
如果（父项==null）{
返回“”；
}
否则{
返回到字符串（parent.left）+“；”+parent.value
+“；”+toString（父项右）；
}
}
私有节点rotateWithLeftChild（节点k2）{
节点k1=k2.左；
k2.左=k1.右；
k1.right=k2；
返回k1；
}
私有节点RotateWithChild（节点k1）{
节点k2=k1.右侧；
k1.右=k2.左；
k2.left=k1；
返回k2；
}
专用节点DoubleRotateThrightChild（节点k3）{
k3.左=第三个旋转儿童（k3.左）；
返回旋转的第三个孩子（k3）；
}
专用节点doubleRotateWithLeftChild（节点k1）{
k1.right=旋转到第四个孩子（k1.right）；
返回第三个孩子（k1）；
}
}
公共类测试树{
公共静态void main（字符串[]args）{
Treee temp=新的Treee（）；
温度插件（10）；
温度插件（20）；
温度插入（30）；
System.out.println（temp.toString（））；
}
}

您正在访问一个空节点。插入第三个节点（值为30）时不会出现任何问题，但此时树中只存在正确的子节点（您添加了一个值为10的节点，它将成为根，然后添加了一个值为20的节点，它将成为根的右子节点，然后添加了一个值为30的节点，它将成为值为20的节点的右子节点）

因此，由于只有正确的子级，当您尝试访问parent.left时，它将为null。因此，当您尝试平衡树时，您应该添加一些逻辑，以确保parent.left和parent.right不为null。我在tree.java文件中添加了一些代码来帮助您开始。但是，看起来您可能会有一些额外的内容要处理的所有问题，因为在我粘贴到下面的代码的第67行中，您尝试访问“parent.right.value”，而不使用任何代码来确保“parent.right”不为空。我还留下了用于调试代码的print语句，以帮助您自己调试代码

public class Tree {
    Node root;

    public Tree() {
        root = null;
    }

    public void insert (int value) {

        if (root == null) {
            root = new Node(null, value);
        }
        else {
            insert(root, value);
        }
    }

    private void insert (Node parent, int value) {

        if (parent.value >= value) {

            if (parent.left == null) {
                parent.left = new Node (parent, value);
            }
            else {
                insert(parent.left, value);

           /////////////////////////    
                if ( parent.left.height() - parent.right.height() == 2) {

                    if (value - parent.left.value < 0) {
                        parent = rotateWithLeftChild(parent);
                    }
                    else {
                        parent = doubleRotateWithRightChild(parent);
                    }
                }           
          /////////////////////////
            }
        }

        else {

            if (parent.right == null) {
                parent.right = new Node (parent, value);
                System.out.println("Node inserted as a right child.");
            }
            else {
                System.out.println("We are in the insert method, before the recursive call");
                insert(parent.right, value);
                System.out.println("We are in the insert method, after the recursive call");
          /////////////////////////
                System.out.println("parent" + parent);
                System.out.println("parent.value " + parent.value);
                System.out.println("parent.left " + parent.left);
                System.out.println("parent.right " + parent.right);
                int leftHeight = 0;
                int rightHeight = 0;
                if( parent.left != null )
                    leftHeight = parent.left.height();

                if( parent.right != null )
                    rightHeight = parent.right.height();

                if ( leftHeight - rightHeight == -2) {

                    if (value - parent.right.value > 0) {
                        parent = rotateWithRightChild(parent);
                    }
                    else {
                        parent = doubleRotateWithLeftChild(parent);
                    }
                }
         /////////////////////////
        }
         }
         }
        public int quantity() {

    if (root == null) {
        return 0;
    }
    else {
        return 1 + quantity(root.left) + quantity(root.right);          
    }
     }
    public int quantity (Node parent) {

    if (parent == null) {
        return 0;
    }
    else {
        return 1 + quantity(parent.left) + quantity(parent.right);
    }
    }
    public int height () {

    int l = 0;
    int r = 0;

    if ( root.left != null) {
        l = height(root.left) + 1;
    }

    if (root.right != null) {
        r = height(root.right) +1;
    }

    return (Math.max(l,r));
    }
    private int height (Node parent) {

    int l = 0;
    int r = 0;

    if ( parent.left != null) {
        l = height(parent.left) + 1;
    }

    if (parent.right != null)   {
        r = height(parent.right) +1;
    }

    return (Math.max(l,r));
    }
    public String toString () {

        if (root == null) {
            return "empty tree";
        }
        else {
            return toString(root.left) + " ; " + root.value + " ; " +  toString(root.right);
        }
    }

    private String toString (Node parent) {

    if (parent == null) {
        return "";
    }
    else {
        return toString(parent.left) + " ; " + parent.value
        + " ; " +     toString(parent.right);
      }
     }
    private Node rotateWithLeftChild (Node k2) {
    Node k1 = k2.left;
    k2.left = k1.right;
    k1.right = k2;

    return k1;
    }
    private Node rotateWithRightChild (Node k1) {
    Node k2 = k1.right;
    k1.right = k2.left;
    k2.left = k1;

    return k2;
    }
    private Node doubleRotateWithRightChild (Node k3) {
    k3.left = rotateWithRightChild(k3.left);

    return rotateWithLeftChild(k3);
    }
    private Node doubleRotateWithLeftChild (Node k1) {
    k1.right = rotateWithLeftChild(k1.right);
    return rotateWithRightChild(k1);
    }

}

公共类树{
节根；
公树（）{
root=null；
}
公共空白插入（int值）{
if（root==null）{
根=新节点（空，值）；
}
否则{
插入（根，值）；
}
}
专用void插入（节点父节点，int值）{
如果（parent.value>=值）{
if（parent.left==null）{
parent.left=新节点（父节点，值）；
}
否则{
插入（parent.left，value）；
/////////////////////////    
if（parent.left.height（）-parent.right.height（）=2）{
if（值-parent.left.value<0）{
家长=轮班