如何在BST中以root身份插入节点？

Question

我们通常在BST中插入节点作为内部节点之一。我发现一个C版本代码将其作为根节点插入。整个过程分为3个步骤Insert node as root：

1. 在BST中搜索插入点

2. 插入新的BST节点

3. 将BST节点移至root

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

Answer 1

正如 Insert node as root:所说：

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

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

摘要：我们可以迭代这两个原则，直到将 new Node 移动到 root 。
这是另一种实施方式：

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);
    }
}