在递归 AVL 树插入期间维护父指针 C++

Question

I am seeking a way to recursively maintain the parent pointer in my AVL tree insert. I am aware that this is not the usual process however I am meant to have a function to manually rotate the nodes so the parent is necessary.

The closest I've gotten is to maintain the parents of the root and the nodes that are not pointing to NULL. all the others will just point to themselves. If I uncomment my other parent insertion, I get segfaults.

AVL::node *AVL::insert(int k, string d, node *&n)
{
    //recursive base  case, I imagine n->parent = n should not be here

    if (n == NULL) {
        n = new node;
        n->left = NULL;
        n->right = NULL;
        n->key = k;
        n->data = d;
        n->height = 1;
        n->parent = n;
        return n;
    }

    if (n->key > k) {
        if (n->left != NULL) {
            n->left->parent = n;
            insert(k, d, n->left);
        } else {
            //n->left->parent = n;
            // this creates SEGFAULT
            insert(k, d, n->left);
        }
    } else if (n->key < k) {
        if (n->right != NULL) {
            n->right->parent = n;
            insert(k, d, n->right);
    } else {
        //n->right->parent = n;
        // this creates SEGFAULT
        insert(k, d, n->right);
    }
  } else {
      return n;
  }

    // insert height management here

    updateHeight(n);
    return n;
}

Answer 1

You almost got it. The remaining piece of the puzzle you missed is:

insert(k, d, n->left);

Your approach of passing in a reference to what would become the pointer that's would be pointing to the newly created node in your AVL tree (in this case this would be n->left ), is the right approach.

Your missing piece is making the obvious observation that the new node needs to know it's parent, and you're staring at it , right here, on the above line. It's n :

insert(k, d, n, n->left);

Now, insert() knows the parent node (and the other recursive call, that uses n->right , does the same thing):

AVL::node *AVL::insert(int k, string d, node *parent, node *&n)

You can completely broom away all that convoluted logic that attempts to fiddle with parent , and whether the pointers were nullptr before/after the recursive calls. Your recursive insert() knows exactly what the parent is, in a much simpler fashion:

    if (n == NULL) {
        n = new node;
        n->left = NULL;
        n->right = NULL;
        n->parent = parent;

That's pretty much it, this becomes a big, fat, nothingburger. Presumably, the initial call to insert() , that start rolling the ball down the hill with the AVL tree's root node will pass a nullptr for the parent parameter, and everything works out by itself.