Java 如何在BST中将节点作为根插入？

我们通常在BST中插入节点作为内部节点之一。我找到了一个C版本代码，将其作为根节点插入。整个过程分为3个步骤：

搜索BST以查找插入点

插入新的BST节点

将BST节点移动到根节点

我想用java写这个。但是，我不明白第三步是如何工作的？

正如所说：

• 如果在插入搜索期间从节点x向下移动到左侧，则在x处向右旋转
• 如果我们向右移动，我们会向左旋转

在第一张图片中，4是右节点，然后我们应该向左旋转并到达第二张图片，现在4是左节点，然后向右旋转并到达第三张图片，4是右节点向左旋转，现在4是根，算法结束

小结：我们可以迭代这两个原则，直到将新节点移动到根节点。
下面是一个替代实现：

class Node{
    Node left,right;
    int val;
    public Node(int val){
        this.val = val;
    }
}

public class BSTDemo {
    public Node insert(Node root,int val){
        Node node = root;
        while(node!=null){
            if(node.val<val){
                if(node.right==null){
                    node.right = new Node(val);
                    return node.right;
                }
                node = node.right;
            }
            else if(node.val>val){
                if(node.left==null){
                    node.left = new Node(val);
                    return node.left;
                }
                node = node.left;
            }
            else{
                return null;
            }
        }
        return null;
    }

    public Node rotate(Node root,Node newNode){
        if(root==newNode){
            return root;
        }
        else{
            Node parent = findParent(root,newNode);
            while(parent!=null){
                Node grandParent = findParent(root,parent);
                if(parent.left==newNode){
                    //right rotate
                    parent.left = newNode.right;
                    newNode.right = parent;
                    if(grandParent!=null){
                        if(grandParent.left==parent){
                            grandParent.left = newNode;
                        }
                        else{
                            grandParent.right = newNode;
                        }
                    }
                }
                else{
                    //left rotate
                    parent.right = newNode.left;
                    newNode.left = parent;
                    if(grandParent!=null){
                        if(grandParent.left==parent){
                            grandParent.left = newNode;
                        }
                        else{
                            grandParent.right = newNode;
                        }
                    }
                }
                parent = findParent(root,newNode);
            }
            return newNode;
        }
    }

    private Node findParent(Node root,Node newNode) {
        if(root==newNode){
            return null;
        }

        Node parent = root;
        while(root!=null){
            if(root.val==newNode.val){
                return parent;
            }
            else if(root.val>newNode.val){
                parent = root;
                root = root.left;
            }
            else{
                parent = root;
                root = root.right;
            }
        }
        return null;
    }

    public static void main(String[] args){
        Node root = new Node(1);
        root.right = new Node(5);
        root.right.left = new Node(3);
        root.right.right = new Node(6);
        root.right.left.left = new Node(2);
        BSTDemo bst = new BSTDemo();
        Node node = bst.insert(root, 4);
        root = bst.rotate(root, node);
    }
}

类节点{
左、右淋巴结；
int-val；
公共节点（int-val）{
this.val=val；
}
}
公开课演示{
公共节点插入（节点根，int val）{
节点=根；
while（节点！=null）{
if（节点阀门）{
if（node.left==null）{
node.left=新节点（val）；
返回node.left；
}
node=node.left；
}
否则{
返回null；
}
}
返回null；
}
公共节点旋转（节点根、节点新节点）{
if（根==newNode）{
返回根；
}
否则{
节点父节点=findParent（根节点，新节点）；
while（父级！=null）{
节点祖父母=findParent（根，父）；
if（parent.left==newNode）{
//右转
parent.left=newNode.right；
newNode.right=父节点；
if（祖父母！=null）{
if（祖父母.左==父母）{
grandParent.left=newNode；
}
否则{
grandParent.right=newNode；
}
}
}
否则{
//左旋转
parent.right=newNode.left；
newNode.left=父节点；
if（祖父母！=null）{
if（祖父母.左==父母）{
grandParent.left=newNode；
}
否则{
grandParent.right=newNode；
}
}
}
父节点=findParent（根节点，新节点）；
}
返回newNode；
}
}
私有节点findParent（节点根、节点newNode）{
if（根==newNode）{
返回null；
}
节点父节点=根节点；
while（root！=null）{
if（root.val==newNode.val）{
返回父母；
}
else if（root.val>newNode.val）{
父=根；
root=root.left；
}
否则{
父=根；
root=root.right；
}
}
返回null；
}
公共静态void main（字符串[]args）{
节点根=新节点（1）；
root.right=新节点（5）；
root.right.left=新节点（3）；
root.right.right=新节点（6）；
root.right.left.left=新节点（2）；
BSTDemo bst=新的BSTDemo（）；
Node=bst.insert（根，4）；
根=bst.rotate（根，节点）；
}
}