Java 红黑树算法不经过旋转

我使用下面的算法。唯一的问题是，在运行时parent.left或parent.right被解析为null，因此它不会在方法insertFix（）中进行旋转。在添加项目时，我尝试添加以下代码

/*if (parent != null)
                {
                    if (value > parent.value)
                    {
                        parent.right = newNode;
                    }
                    else {
                        parent.left = newNode;
                    }
                }*/

但是，这会导致stackoverflow异常。请提供有关如何解决此问题的帮助

 public void insertRBT(int value)
    {
        root=insertNode(root, value,null);
        count += 1;   
    }


    protected BNode insertNode(BNode rt, int value, BNode parent)
    {
        BNode grandParent, greatGrandParent;
        if (rt == null)
        {
            BNode newNode = new BNode(value, parent);
            parent = newNode.parent;

            /*if (parent != null)
            {
                if (value > parent.value)
                {
                    parent.right = newNode;
                }
                else {
                    parent.left = newNode;
                }
            }*/
            if (count > 0)
            {
                newNode.red = true;
            }
            else
            {
                newNode.red = false;
            }
            //added

            insertedNode = newNode;
            grandParent = null;
            greatGrandParent = null;
            insertFix(newNode,parent,grandParent,greatGrandParent);
            return newNode;
        }
        else if (value.CompareTo(rt.value) < 0)
        {
            rt.left = insertNode(rt.left, value, rt);
            return rt;
        }else //if(value.CompareTo(rt.value)> 0)
        {
            rt.right = insertNode(rt.right, value, rt);
            return rt;
        }
    }

    private void insertFix(BNode node, BNode parent, BNode grandParent, BNode greatGrandParent)
    {

       if(count>0)
            parent = node.parent;
        if(parent!=null)
            grandParent = GrandParent(node);
        BNode uncle = Uncle(node);
        if(grandParent!=null)
         greatGrandParent = grandParent.parent;

        if(grandParent!=null)
        {
            if (uncle != null && parent.red && uncle.red)
            {
                uncle.red = false;
                parent.red = false;
                grandParent.red = true;
                BNode higher = null;
                BNode stillhigher = null;
                if (greatGrandParent != null)
                {
                    higher = greatGrandParent.parent;
                } if (higher != null)
                {
                    stillhigher = higher.parent;
                }
                insertFix(grandParent, greatGrandParent, higher, stillhigher);
            } else if (uncle == null || parent.red && !uncle.red)
            {
                if (grandParent.right == parent && parent.right == node)
                {
                    parent.red = false;
                    grandParent.red = true;
                    if (greatGrandParent != null)
                    {
                        if (greatGrandParent.right == grandParent)
                        {
                            LeftRotate(grandParent);
                            greatGrandParent.right = grandParent;
                        }
                        else
                        {
                            LeftRotate(grandParent);
                            greatGrandParent.left = grandParent;
                        }
                    }
                    else
                    {
                        LeftRotate(root);
                    }
                }
            } else if (grandParent.left == parent && parent.left == node)
            {
                parent.red = false;
                grandParent.red = true; //changed
                if(greatGrandParent!=null)
                {
                    if(greatGrandParent.right==grandParent)
                    {
                        RightRotate(grandParent);
                        greatGrandParent.right = grandParent;
                    }else
                    {
                        RightRotate(grandParent);
                        greatGrandParent.left = grandParent;
                    }
                }
                else
                {
                    RightRotate(root);
                }
            }else if(grandParent.right==parent && parent.left==node) //wasalt
            {
                node.red = false;
                grandParent.red = true; //changed
                RightRotate(parent);
                grandParent.right = parent;
                if(greatGrandParent!=null)
                {
                    if(greatGrandParent.right==grandParent)
                    {
                        LeftRotate(grandParent);
                        greatGrandParent.right = grandParent;
                    }
                    else
                    {
                        LeftRotate(grandParent);
                        greatGrandParent.left = grandParent;
                    }
                }else
                {
                    LeftRotate(root);
                }
            }else if(grandParent.left==parent && parent.right==node)
            {
                node.red = false;
                grandParent.red = true;
                LeftRotate(parent);
                grandParent.left = parent;
                if(greatGrandParent!=null)
                {
                    if(greatGrandParent.right == grandParent)
                    {
                        RightRotate(grandParent);
                        greatGrandParent.right = grandParent;
                    }else
                    {
                        RightRotate(grandParent);
                        greatGrandParent.left = grandParent;
                    }
                }else
                {
                    RightRotate(root);
                }
            }
            root.red = false;
        }
   }

    //GrandParent
    public BNode GrandParent(BNode node)
    {
        if ((node != null) && (node.parent != null))
        {
            return node.parent.parent;
        }
        else
            return null;
    }

    //Uncle
    public BNode Uncle(BNode node)
    {
        BNode gp = GrandParent(node);
        if (gp == null)
        {
            return null;
        }
        if (node.parent == gp.left)
        {
            return gp.right;
        }
        else
        {
            return gp.left;
        }
    }

public void insertRBT（int值）
{
root=insertNode（root，value，null）；
计数+=1；
}
受保护的BNode insertNode（BNode rt、int值、BNode父节点）
{
B祖父母，曾祖父母；
if（rt==null）
{
BNode newNode=新BNode（值，父级）；
parent=newNode.parent；
/*如果（父项！=null）
{
如果（值>父值）
{
parent.right=newNode；
}
否则{
parent.left=newNode；
}
}*/
如果（计数>0）
{
newNode.red=true；
}
其他的
{
newNode.red=false；
}
//增加
insertedNode=newNode；
祖父母=null；
曾祖父母=null；
insertFix（新节点、父节点、祖父母、曾祖父母）；
返回newNode；
}
否则如果（值比较到（rt.value）<0）
{
rt.left=插入节点（rt.left，value，rt）；
返回rt；
}else//if（value.CompareTo（rt.value）>0）
{
rt.right=插入节点（rt.right，value，rt）；
返回rt；
}
}
私有void insertFix（BNode节点、BNode父节点、BNode祖父母、BNode曾祖父母）
{
如果（计数>0）
parent=node.parent；
如果（父项！=null）
祖父母=祖父母（节点）；
BNode叔叔=叔叔（节点）；
if（祖父母！=null）
曾祖父母=祖父母。父母；
if（祖父母！=null）
{
if（叔叔！=null&&parent.red&&叔叔.red）
{
叔叔红=假；
parent.red=false；
祖父母红=真；
BNode更高=空；
BNode stillhigher=null；
if（曾祖父母！=null）
{
较高=曾祖父母。父母；
}如果（更高！=null）
{
stillhigher=更高的父级；
}
insertFix（祖父母、曾祖父母、更高、仍然更高）；
}else if（uncle==null | | parent.red&&！uncle.red）
{
if（grandParent.right==parent&&parent.right==node）
{
parent.red=false；
祖父母红=真；
if（曾祖父母！=null）
{
if（greatGrandParent.right==祖父母）
{
左撇子（祖父母）；
great祖父母。右=祖父母；
}
其他的
{
左撇子（祖父母）；
great祖父母。左=祖父母；
}
}
其他的
{
左旋转（根）；
}
}
}else if（grandParent.left==parent&&parent.left==node）
{
parent.red=false；
grandParent.red=true；//已更改
if（曾祖父母！=null）
{
if（曾祖父母。右==祖父母）
{
右旋（祖父母）；
great祖父母。右=祖父母；
}否则
{
右旋（祖父母）；
great祖父母。左=祖父母；
}
}
其他的
{
右旋转（根）；
}
}else if（grandParent.right==parent&&parent.left==node）//wasalt
{
node.red=false；
grandParent.red=true；//已更改
右旋转（父）；
祖父母。右=父母；
if（曾祖父母！=null）
{
if（曾祖父母。右==祖父母）
{
左撇子（祖父母）；
great祖父母。右=祖父母；
}
其他的
{
左撇子（祖父母）；
great祖父母。左=祖父母；
}
}否则
{
左旋转（根）；
}
}else if（grandParent.left==parent&&parent.right==node）
{
node.red=false；
祖父母红=真；
左旋转（父级）；
祖父母。左=父母；
if（曾祖父母！=null）
{
if（greatGrandParent.right==祖父母）
{
右旋（祖父母）；
great祖父母。右=祖父母；
}否则
{
右旋（祖父母）；
great祖父母。左=祖父母；
}
}否则
{
右旋转（根）；
}
}
root.red=false；
}
}
//祖父母
公共B节点