带有父指针的二进制搜索树插入

我们已经讨论了简单的BST插入。如何在需要维护父指针的树中插入。父指针有助于快速找到节点的祖先，两个节点的LCA，节点的后继者等。

在简单插入的递归调用中，我们返回在子树中创建的子树的根的指针。因此，想法是为左右子树存储此指针。我们在递归调用之后设置此返回指针的父指针。这样可以确保在插入过程中设置了所有父指针。根的父级设置为NULL。我们通过默认为所有新分配的节点将parent分配为NULL来处理此问题。

C++

// C++ program to demonstrate insert operation
// in binary search tree with parent pointer
#include
  
struct Node
{
    int key;
    struct Node *left, *right, *parent;
};
  
// A utility function to create a new BST Node
struct Node *newNode(int item)
{
    struct Node *temp =  new Node;
    temp->key = item;
    temp->left = temp->right = NULL;
    temp->parent = NULL;
    return temp;
}
  
// A utility function to do inorder traversal of BST
void inorder(struct Node *root)
{
    if (root != NULL)
    {
        inorder(root->left);
        printf("Node : %d, ", root->key);
        if (root->parent == NULL)
          printf("Parent : NULL \n");
        else
          printf("Parent : %d \n", root->parent->key);
        inorder(root->right);
    }
}
  
/* A utility function to insert a new Node with
   given key in BST */
struct Node* insert(struct Node* node, int key)
{
    /* If the tree is empty, return a new Node */
    if (node == NULL) return newNode(key);
  
    /* Otherwise, recur down the tree */
    if (key < node->key)
    {
        Node *lchild = insert(node->left, key);
        node->left  = lchild;
  
        // Set parent of root of left subtree
        lchild->parent = node;
    }
    else if (key > node->key)
    {
        Node *rchild = insert(node->right, key);
        node->right  = rchild;
  
        // Set parent of root of right subtree
        rchild->parent = node;
    }
  
    /* return the (unchanged) Node pointer */
    return node;
}
  
// Driver Program to test above functions
int main()
{
    /* Let us create following BST
              50
           /     \
          30      70
         /  \    /  \
       20   40  60   80 */
    struct Node *root = NULL;
    root = insert(root, 50);
    insert(root, 30);
    insert(root, 20);
    insert(root, 40);
    insert(root, 70);
    insert(root, 60);
    insert(root, 80);
  
    // print iNoder traversal of the BST
    inorder(root);
  
    return 0;
}

Java

// Java program to demonstrate insert operation 
// in binary search tree with parent pointer 
class GfG { 
  
static class Node 
{ 
    int key; 
    Node left, right, parent; 
}
  
// A utility function to create a new BST Node 
static Node newNode(int item) 
{ 
    Node temp = new Node(); 
    temp.key = item; 
    temp.left = null;
    temp.right = null; 
    temp.parent = null; 
    return temp; 
} 
  
// A utility function to do inorder traversal of BST 
static void inorder(Node root) 
{ 
    if (root != null) 
    { 
        inorder(root.left); 
        System.out.print("Node : "+ root.key + " , "); 
        if (root.parent == null) 
        System.out.println("Parent : NULL"); 
        else
        System.out.println("Parent : " + root.parent.key); 
        inorder(root.right); 
    } 
} 
  
/* A utility function to insert a new Node with 
given key in BST */
static Node insert(Node node, int key) 
{ 
    /* If the tree is empty, return a new Node */
    if (node == null) return newNode(key); 
  
    /* Otherwise, recur down the tree */
    if (key < node.key) 
    { 
        Node lchild = insert(node.left, key); 
        node.left = lchild; 
  
        // Set parent of root of left subtree 
        lchild.parent = node; 
    } 
    else if (key > node.key) 
    { 
        Node rchild = insert(node.right, key); 
        node.right = rchild; 
  
        // Set parent of root of right subtree 
        rchild.parent = node; 
    } 
  
    /* return the (unchanged) Node pointer */
    return node; 
} 
  
// Driver Program to test above functions 
public static void main(String[] args) 
{ 
    /* Let us create following BST 
            50 
        /     \ 
        30     70 
        / \ / \ 
    20 40 60 80 */
    Node root = null; 
    root = insert(root, 50); 
    insert(root, 30); 
    insert(root, 20); 
    insert(root, 40); 
    insert(root, 70); 
    insert(root, 60); 
    insert(root, 80); 
  
    // print iNoder traversal of the BST 
    inorder(root); 
}
}

Python3

# Python3 program to demonstrate insert operation 
# in binary search tree with parent pointer 
  
# A utility function to create a new BST Node 
class newNode:
    def __init__(self, item):
        self.key = item 
        self.left = self.right = None
        self.parent = None
  
# A utility function to do inorder 
# traversal of BST 
def inorder(root):
    if root != None:
        inorder(root.left)
        print("Node :", root.key, ", ", end = "") 
        if root.parent == None:
            print("Parent : NULL") 
        else:
            print("Parent : ", root.parent.key)
        inorder(root.right)
  
# A utility function to insert a new 
# Node with given key in BST 
def insert(node, key):
      
    # If the tree is empty, return a new Node 
    if node == None:
        return newNode(key) 
  
    # Otherwise, recur down the tree 
    if key < node.key:
        lchild = insert(node.left, key) 
        node.left = lchild 
  
        # Set parent of root of left subtree 
        lchild.parent = node
    elif key > node.key:
        rchild = insert(node.right, key) 
        node.right = rchild 
  
        # Set parent of root of right subtree 
        rchild.parent = node
  
    # return the (unchanged) Node pointer 
    return node
  
# Driver Code
if __name__ == '__main__':
      
    # Let us create following BST 
    #         50 
    #     /     \ 
    #     30     70 
    #     / \ / \ 
    # 20 40 60 80 
    root = None
    root = insert(root, 50) 
    insert(root, 30) 
    insert(root, 20) 
    insert(root, 40) 
    insert(root, 70) 
    insert(root, 60) 
    insert(root, 80) 
  
    # print iNoder traversal of the BST 
    inorder(root)
  
# This code is contributed by PranchalK

C#

// C# program to demonstrate insert operation 
// in binary search tree with parent pointer 
using System;
  
class GfG 
{ 
    class Node 
    { 
        public int key; 
        public Node left, right, parent; 
    } 
  
    // A utility function to create a new BST Node 
    static Node newNode(int item) 
    { 
        Node temp = new Node(); 
        temp.key = item; 
        temp.left = null; 
        temp.right = null; 
        temp.parent = null; 
        return temp; 
    } 
  
    // A utility function to do 
    // inorder traversal of BST 
    static void inorder(Node root) 
    { 
        if (root != null) 
        { 
            inorder(root.left); 
            Console.Write("Node : "+ root.key + " , "); 
            if (root.parent == null) 
            Console.WriteLine("Parent : NULL"); 
            else
            Console.WriteLine("Parent : " +
                                root.parent.key); 
            inorder(root.right); 
        } 
    } 
  
    /* A utility function to insert a new Node with 
    given key in BST */
    static Node insert(Node node, int key) 
    { 
        /* If the tree is empty, return a new Node */
        if (node == null) return newNode(key); 
  
        /* Otherwise, recur down the tree */
        if (key < node.key) 
        { 
            Node lchild = insert(node.left, key); 
            node.left = lchild; 
  
            // Set parent of root of left subtree 
            lchild.parent = node; 
        } 
        else if (key > node.key) 
        { 
            Node rchild = insert(node.right, key); 
            node.right = rchild; 
  
            // Set parent of root of right subtree 
            rchild.parent = node; 
        } 
  
        /* return the (unchanged) Node pointer */
        return node; 
    } 
  
    // Driver code 
    public static void Main(String[] args) 
    { 
        /* Let us create following BST 
                50 
            / \ 
            30 70 
            / \ / \ 
        20 40 60 80 */
        Node root = null; 
        root = insert(root, 50); 
        insert(root, 30); 
        insert(root, 20); 
        insert(root, 40); 
        insert(root, 70); 
        insert(root, 60); 
        insert(root, 80); 
  
        // print iNoder traversal of the BST 
        inorder(root); 
    } 
} 
  
// This code is contributed 29AjayKumar

输出 ：

Node : 20, Parent : 30 
Node : 30, Parent : 50 
Node : 40, Parent : 30 
Node : 50, Parent : NULL 
Node : 60, Parent : 70 
Node : 70, Parent : 50 
Node : 80, Parent : 70 

锻炼：
在删除过程中如何维护父指针。