C ++如果指针指向nullptr，我可以将其替换为数字吗？

Question

Hey guys, I encountered some problems about C++. Actually it's not the problem of language feature, otherwise it is related to kind of coding style.
OK, Let's get to the point!
I try to write the AVL Tree and want to calculate the balance factors, and according the rule, the subtree without nodes(just a empty tree), its height should be treated as -1 . Yeah, everything thinks fine, but when I write the code, use pointer to read Node class member, I cannot read the nullptr BAD ACCESS , so I add lots of conditions, which makes my code look bad. Here is some parts of my code.

struct Node{
    int key;
    int height;
    Node* left;
    Node* right;
    Node* parent;
    Node(void);
    Node(int key);
};

    while((parent_node->left->height - parent_node->right->height) <= 1
          ||(parent_node->left->height - parent_node->right->height) >= (-1))
    {
        parent_node = parent_node->parent;
        if(parent_node == nullptr) break;
    }

The result I want is that when the parent_node's left subtree is empty, its height will be treated as -1. And the fact is, though it's empty, its height should not exist. So in the code I only list four cases
1. left subtree == nullptr && right subtree == nullptr
2. left subtree != nullptr && right subtree == nullptr
3. left subtree != nullptr && right subtree != nullptr
4. left subtree == nullptr && right subtree != nullptr
Then I replace the code of height part with the value -1 respectively. It feels painful. And this condition happens in my coding time many times, I want to find the better solution.

My English is not that good, so my description maybe sort of misleading, I will appreciate it if you help me in any way.

Answer 1

Create a function that compute the height of a subtree including the special cases, and use that instead of accessing the ->height data member:

int heightOfSubtree(Node* tree) {
    if (tree == nullptr) {
        return -1;
    }
    else {
        return tree-> height;
    }
}

then your code becomes:

while((heightOfSubtree(parent_node->left) - heightOfSubtree(parent_node->right)) <= 1
      ||((heightOfSubtree(parent_node->left) - heightOfSubtree(parent_node->right)) >= (-1))
{
    ...
}

or better, you can define a member function in the Node structure such as this:

bool Node::isBalanced() {
    int unb = heightOfSubtree(left) - heightOfSubtree(right);
    return (unb <= 1) || (unb >=-1);
} 

and your while condition becomes:

while(parent_node->isBalanced()) {
    ...
}

ps: I believe there is a logical error in your code: I am not sure the condition you are checking is correct, since it is always true (any number is either bigger than -1 or smaller than 1, for some both are true)

Answer 2

Unless I misunderstand, you could point to a sentinel node in stead of null as the terminator link. Set the height of the sentinel to -1 and it doesn't need to be handled differently for that part of the algorithm.