红黑树

红黑树（Red-Black Tree）是一种二叉查找树（Binary Search Tree），但作了改进，即在每个结点上增加一个存储位表示结点的颜色，可以是RED或BLACK。通过对任何一条从根到叶子的路径上各个结点的着色方式的限制，红黑树确保没有一条路径会比其他路径长出两倍，因而是接近平衡的。

　　红黑树的每个节点属性包含五个域：color、key、parent、lchild、rchild。红黑树除了具有二叉搜索树的所有性质之外，还具有以下性质：

　　1. 每个结点或是红的，或是黑的。

　　2. 根结点是黑的。

　　3. 每个叶结点是黑的。

　　4. 如果一个结点是红的，则它的两个孩子都是黑的。

　　5. 对每个结点，从该结点到其子孙结点的所有路径上包含相同数目的黑结点。

　　以上这些规则可以保证整棵树的平衡，红黑树的高度和查找时间都为O（log N）。

　　二叉查找树在最坏的情况下可能会变成一个链表（当所有节点按从小到大的顺序依次插入后）。而红黑树在每一次插入或删除节点之后都会花O（log N）的时间来对树的结构作修改，以保证红黑树的性质，从而保持树的平衡。因此，红黑树的查找方法与二叉查找树相同，而Insert和Delete结点的的方法前半部分与二叉查找树相同，而后半部分添加了一些修改树红黑树结构的操作。具体分析请参见“算法导论”一书第13章。下面给出一种红黑树的C实现，修改自Linux内核源码中的红黑树实现(rbtree.h, rbtree.c)。

rbtree.h

#ifndef _RBTREE_H #define _RBTREE_H #include <stdio.h> #define RB_RED 0 #define RB_BLACK 1 struct rb_key { int key; }; struct rb_node { struct rb_node *rb_parent; struct rb_node *rb_right; struct rb_node *rb_left; struct rb_key rb_key; int rb_color; }; struct rb_root { struct rb_node *rb_node; }; #define rb_parent(r) ((struct rb_node *)((r)->rb_parent)) #define rb_color(r) ((r)->rb_color) #define rb_is_red(r) (!rb_color(r)) #define rb_is_black(r) rb_color(r) #define rb_set_red(r) do { (r)->rb_color = RB_RED; } while (0) #define rb_set_black(r) do { (r)->rb_color = RB_BLACK; } while (0) static inline void rb_set_parent(struct rb_node *rb, struct rb_node *p) { rb->rb_parent = p; } static inline void rb_set_color(struct rb_node *rb, int color) { rb->rb_color = color; } #define RB_ROOT (struct rb_root) { NULL, } #define RB_EMPTY_ROOT(root) ((root)->rb_node == NULL) #define RB_EMPTY_NODE(node) (rb_parent(node) == node) #define RB_CLEAR_NODE(node) (rb_set_parent(node, node)) extern void rb_insert_color(struct rb_node *, struct rb_root *); extern void rb_erase(struct rb_node *, struct rb_root *); extern void rb_insert(struct rb_node *, struct rb_root *); extern void rb_traverse(struct rb_node *); extern struct rb_node *rb_newnode(struct rb_key *); extern struct rb_node *rb_search(struct rb_root *, struct rb_key); /* Find logical next and previous nodes in a tree */ extern struct rb_node *rb_next(struct rb_node *); extern struct rb_node *rb_prev(struct rb_node *); extern struct rb_node *rb_first(struct rb_root *); extern struct rb_node *rb_last(struct rb_root *); /* Fast replacement of a single node without remove/rebalance/add/rebalance */ extern void rb_replace_node(struct rb_node *victim, struct rb_node *new_node, struct rb_root *root); static inline void rb_link_node(struct rb_node * node, struct rb_node * parent, struct rb_node ** rb_link) { node->rb_parent = parent; node->rb_left = node->rb_right = NULL; *rb_link = node; } #endif

rbtree.c

#include <stdio.h> #include <stdlib.h> #include <string.h> #include "rbtree.h" static void __rb_rotate_left(struct rb_node *node, struct rb_root *root) { struct rb_node *right = node->rb_right; struct rb_node *parent = rb_parent(node); if ((node->rb_right = right->rb_left)) rb_set_parent(right->rb_left, node); right->rb_left = node; rb_set_parent(right, parent); if (parent) { if (node == parent->rb_left) parent->rb_left = right; else parent->rb_right = right; } else root->rb_node = right; rb_set_parent(node, right); } static void __rb_rotate_right(struct rb_node *node, struct rb_root *root) { struct rb_node *left = node->rb_left; struct rb_node *parent = rb_parent(node); if ((node->rb_left = left->rb_right)) rb_set_parent(left->rb_right, node); left->rb_right = node; rb_set_parent(left, parent); if (parent) { if (node == parent->rb_right) parent->rb_right = left; else parent->rb_left = left; } else root->rb_node = left; rb_set_parent(node, left); } void rb_insert_color(struct rb_node *node, struct rb_root *root) { struct rb_node *parent, *gparent; while ((parent = rb_parent(node)) && rb_is_red(parent)) { gparent = rb_parent(parent); if (parent == gparent->rb_left) { // node is left child of parent { struct rb_node *uncle = gparent->rb_right; if (uncle && rb_is_red(uncle)) { // case 1 rb_set_black(uncle); rb_set_black(parent); rb_set_red(gparent); node = gparent; continue; } } if (parent->rb_right == node) { // case 2 struct rb_node *tmp; __rb_rotate_left(parent, root); tmp = parent; parent = node; node = tmp; } // case 3 rb_set_black(parent); rb_set_red(gparent); __rb_rotate_right(gparent, root); } else { // node is right child of parent { struct rb_node *uncle = gparent->rb_left; if (uncle && rb_is_red(uncle)) { // case 1 rb_set_black(uncle); rb_set_black(parent); rb_set_red(gparent); node = gparent; continue; } } if (parent->rb_left == node) { // case 2 struct rb_node *tmp; __rb_rotate_right(parent, root); tmp = parent; parent = node; node = tmp; } // case 3 rb_set_black(parent); rb_set_red(gparent); __rb_rotate_left(gparent, root); } } rb_set_black(root->rb_node); } static int rb_compare(struct rb_key key1, struct rb_key key2) { return (key1.key - key2.key); } struct rb_node* rb_newnode(struct rb_key *rb_key) { struct rb_node *node = (struct rb_node *)malloc(sizeof(struct rb_node)); if (node) { node->rb_parent = NULL; node->rb_left = NULL; node->rb_right = NULL; node->rb_color = RB_RED; memcpy(&node->rb_key, rb_key, sizeof(struct rb_key)); } return node; } void rb_insert(struct rb_node *node, struct rb_root *root) { struct rb_node *p = root->rb_node; struct rb_node *q = NULL; while (p != NULL) { q = p; if (rb_compare(node->rb_key, p->rb_key) < 0) p = p->rb_left; else p = p->rb_right; } node->rb_parent = q; if (q == NULL) { root->rb_node = node; } else { if (rb_compare(node->rb_key, q->rb_key) < 0) q->rb_left = node; else q->rb_right = node; } rb_insert_color(node, root); } static void __rb_erase_color(struct rb_node *node, struct rb_node *parent, struct rb_root *root) { struct rb_node *other; while ((!node || rb_is_black(node)) && node != root->rb_node) { if (parent->rb_left == node) { other = parent->rb_right; // case 1 if (rb_is_red(other)) { rb_set_black(other); rb_set_red(parent); __rb_rotate_left(parent, root); other = parent->rb_right; } // case 2 if ((!other->rb_left || rb_is_black(other->rb_left)) && (!other->rb_right || rb_is_black(other->rb_right))) { rb_set_red(other); node = parent; parent = rb_parent(node); } else { // case 3 if (!other->rb_right || rb_is_black(other->rb_right)) { struct rb_node *o_left; if ((o_left = other->rb_left)) rb_set_black(o_left); rb_set_red(other); __rb_rotate_right(other, root); other = parent->rb_right; } // case 4 rb_set_color(other, rb_color(parent)); rb_set_black(parent); if (other->rb_right) rb_set_black(other->rb_right); __rb_rotate_left(parent, root); node = root->rb_node; break; } } else { other = parent->rb_left; // case 1 if (rb_is_red(other)) { rb_set_black(other); rb_set_red(parent); __rb_rotate_right(parent, root); other = parent->rb_left; } // case 2 if ((!other->rb_left || rb_is_black(other->rb_left)) && (!other->rb_right || rb_is_black(other->rb_right))) { rb_set_red(other); node = parent; parent = rb_parent(node); } else { // case 3 if (!other->rb_left || rb_is_black(other->rb_left)) { register struct rb_node *o_right; if ((o_right = other->rb_right)) rb_set_black(o_right); rb_set_red(other); __rb_rotate_left(other, root); other = parent->rb_left; } // case 4 rb_set_color(other, rb_color(parent)); rb_set_black(parent); if (other->rb_left) rb_set_black(other->rb_left); __rb_rotate_right(parent, root); node = root->rb_node; break; } } } if (node) rb_set_black(node); } void rb_erase(struct rb_node *node, struct rb_root *root) { struct rb_node *child, *parent; int color; if (!node->rb_left) child = node->rb_right; else if (!node->rb_right) child = node->rb_left; else { struct rb_node *old = node, *left; node = node->rb_right; while ((left = node->rb_left) != NULL) node = left; child = node->rb_right; parent = rb_parent(node); color = rb_color(node); if (child) rb_set_parent(child, parent); if (parent == old) { parent->rb_right = child; parent = node; } else parent->rb_left = child; node->rb_color = old->rb_color; node->rb_parent = old->rb_parent; node->rb_right = old->rb_right; node->rb_left = old->rb_left; if (rb_parent(old)) { if (rb_parent(old)->rb_left == old) rb_parent(old)->rb_left = node; else rb_parent(old)->rb_right = node; } else root->rb_node = node; rb_set_parent(old->rb_left, node); if (old->rb_right) rb_set_parent(old->rb_right, node); goto color; } parent = rb_parent(node); color = rb_color(node); if (child) rb_set_parent(child, parent); if (parent) { if (parent->rb_left == node) parent->rb_left = child; else parent->rb_right = child; } else root->rb_node = child; color: if (color == RB_BLACK) __rb_erase_color(child, parent, root); } struct rb_node *rb_first(struct rb_root *root) { struct rb_node *n; n = root->rb_node; if (!n) return NULL; while (n->rb_left) n = n->rb_left; return n; } struct rb_node *rb_last(struct rb_root *root) { struct rb_node *n; n = root->rb_node; if (!n) return NULL; while (n->rb_right) n = n->rb_right; return n; } struct rb_node *rb_next(struct rb_node *node) { struct rb_node *parent; if (rb_parent(node) == node) return NULL; /* If we have a right-hand child, go down and then left as far as we can. */ if (node->rb_right) { node = node->rb_right; while (node->rb_left) node=node->rb_left; return node; } /* No right-hand children. Everything down and left is smaller than us, so any 'next' node must be in the general direction of our parent. Go up the tree; any time the ancestor is a right-hand child of its parent, keep going up. First time it's a left-hand child of its parent, said parent is our 'next' node. */ while ((parent = rb_parent(node)) && node == parent->rb_right) node = parent; return parent; } struct rb_node *rb_prev(struct rb_node *node) { struct rb_node *parent; if (rb_parent(node) == node) return NULL; /* If we have a left-hand child, go down and then right as far as we can. */ if (node->rb_left) { node = node->rb_left; while (node->rb_right) node=node->rb_right; return node; } /* No left-hand children. Go up till we find an ancestor which is a right-hand child of its parent */ while ((parent = rb_parent(node)) && node == parent->rb_left) node = parent; return parent; } void rb_replace_node(struct rb_node *victim, struct rb_node *new_node, struct rb_root *root) { struct rb_node *parent = rb_parent(victim); /* Set the surrounding nodes to point to the replacement */ if (parent) { if (victim == parent->rb_left) parent->rb_left = new_node; else parent->rb_right = new_node; } else { root->rb_node = new_node; } if (victim->rb_left) rb_set_parent(victim->rb_left, new_node); if (victim->rb_right) rb_set_parent(victim->rb_right, new_node); /* Copy the pointers/colour from the victim to the replacement */ *new_node = *victim; } struct rb_node *rb_search(struct rb_root *root, struct rb_key key) { struct rb_node *p = root->rb_node; while(p != NULL && rb_compare(p->rb_key, key) != 0) { p = (rb_compare(p->rb_key, key) > 0) ? p->rb_left : p->rb_right; } return p; } void rb_traverse(struct rb_node *p) { if (p) { if (p->rb_left) rb_traverse(p->rb_left); printf(" %d ", p->rb_key.key); if (p->rb_right) rb_traverse(p->rb_right); } }

demo.c

#include <stdio.h> #include <stdlib.h> #include "rbtree.h" int main(int argc, char *argv[]) { int i; struct rb_root root; root.rb_node = NULL; for (i = 2; i < argc; i++ ) { struct rb_key rb_key; rb_key.key = atol(argv[i]); struct rb_node *node = rb_newnode(&rb_key); if (node) { rb_insert(node, &root); } } rb_traverse(root.rb_node); printf("/n"); struct rb_key rb_key; rb_key.key = atol(argv[1]); struct rb_node *node = rb_search(&root, rb_key); if (node) { printf("key = %d/n", node->rb_key.key); rb_erase(node, &root); rb_traverse(root.rb_node); printf("/n"); } else { printf("%d is not found/n", rb_key.key); } return 0; }

( Aiguille.LIU / 刘爱贵, [email protected])

参考文献：

[1] 算法导论

[2] 一篇讨论红黑树的好文章:http://imlazy.ycool.com/post.1104022.html