为什么红黑树中的自引用标记比检查NULL更简单？

Question

I'm trying to implement red-black tree data structure and came across this example from Apple Open Source project. This is the code for creating a tree:

/*
 * Create a red black tree struct using the specified compare routine.
 * Allocates and returns the initialized (empty) tree.
 */
struct rbtree *
rbcreate(compar)
    int (*compar)__P((const void *, const void*));
{
    struct rbtree *tree;

    tree = (struct rbtree *) emalloc(sizeof(*tree));
    tree->compar = compar;

    /*
     * We use a self-referencing sentinel node called nil to simplify the
     * code by avoiding the need to check for NULL pointers.
     */
    tree->nil.left = tree->nil.right = tree->nil.parent = &tree->nil;
    tree->nil.color = black;
    tree->nil.data = NULL;

    /*
     * Similarly, the fake root node keeps us from having to worry
     * about splitting the root.
     */
    tree->root.left = tree->root.right = tree->root.parent = &tree->nil;
    tree->root.color = black;
    tree->root.data = NULL;

    return(tree);
}

I'm wondering what is the reasoning behind having the sentinel node instead having the children pointing to NULL . In any case we have to check as far as I understand.

Also I don't understand why we need fake root and how the root can even be split in theory?

Answer 1

Let's say you want to check one of the main properties of the RB tree, that there are no adjacent red nodes.

With NULL representation, it looks like this:

node->color == black || (node->left == NULL || node->left->color == black) && (node->right == NULL || node->right->color == black)

Sentinel representation allows to express it more concisely:

node->color == black || node->left->color == black && node->right->color == black

Same simplification applies to the actual checks in the tree operations.

Similar story with the fake root. It ensures that the tree is never empty, and thus eliminates a special case from the tree insertion routine. (No idea what they meant by spitting though.)