rbtree.c

Go to the documentation of this file.

/*
 * Copyright (c) 2019 Cisco and/or its affiliates.
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at:
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
/*
 * Algorithm from:
 * Cormen, T. H., Leiserson, C. E., Rivest, R. L., & Stein, C. (2009).
 * Introduction to algorithms. MIT press, 3rd Edition, Ch. 13
 */
 
#include <vppinfra/rbtree.h>
 
static inline void
rb_tree_rotate_left (rb_tree_t * rt, rb_node_t * x)
{
  rb_node_t *y, *tmp, *xp;
  rb_node_index_t xi, yi;
 
  xi = rb_node_index (rt, x);
  yi = x->right;
  y = rb_node_right (rt, x);
  x->right = y->left;
  if (y->left != RBTREE_TNIL_INDEX)
    {
      tmp = rb_node_left (rt, y);
      tmp->parent = xi;
    }
  xp = rb_node_parent (rt, x);
  y->parent = x->parent;
  if (x->parent == RBTREE_TNIL_INDEX)
    rt->root = rb_node_index (rt, y);
  else if (xp->left == xi)
    xp->left = yi;
  else
    xp->right = yi;
  y->left = xi;
  x->parent = yi;
}
 
static inline void
rb_tree_rotate_right (rb_tree_t * rt, rb_node_t * y)
{
  rb_node_index_t yi, xi;
  rb_node_t *x, *yp;
 
  yi = rb_node_index (rt, y);
  xi = y->left;
  x = rb_node_left (rt, y);
  y->left = x->right;
  if (x->right != RBTREE_TNIL_INDEX)
    {
      rb_node_t *tmp = rb_node_right (rt, x);
      tmp->parent = yi;
    }
  yp = rb_node_parent (rt, y);
  x->parent = y->parent;
  if (y->parent == RBTREE_TNIL_INDEX)
    rt->root = rb_node_index (rt, x);
  else if (yp->right == yi)
    yp->right = xi;
  else
    yp->left = xi;
  x->right = yi;
  y->parent = xi;
}
 
static inline void
rb_tree_fixup_inline (rb_tree_t * rt, rb_node_t * y, rb_node_t * z)
{
  rb_node_t *zpp, *zp;
  rb_node_index_t zi;
 
  while (y->color == RBTREE_RED)
    {
      zi = rb_node_index (rt, z);
      zp = rb_node_parent (rt, z);
      zpp = rb_node_parent (rt, zp);
      if (z->parent == zpp->left)
        {
          y = rb_node_right (rt, zpp);
          if (y->color == RBTREE_RED)
            {
              zp->color = RBTREE_BLACK;
              y->color = RBTREE_BLACK;
              zpp->color = RBTREE_RED;
              z = zpp;
            }
          else
            {
              if (zi == zp->right)
                {
                  z = zp;
                  rb_tree_rotate_left (rt, z);
                  zp = rb_node (rt, z->parent);
                  zpp = rb_node (rt, zp->parent);
                }
              zp->color = RBTREE_BLACK;
              zpp->color = RBTREE_RED;
              rb_tree_rotate_right (rt, zpp);
            }
        }
      else
        {
          y = rb_node (rt, zpp->left);
          if (y->color == RBTREE_RED)
            {
              zp->color = RBTREE_BLACK;
              y->color = RBTREE_BLACK;
              zpp->color = RBTREE_RED;
              z = zpp;
            }
          else
            {
              if (zi == zp->left)
                {
                  z = zp;
                  rb_tree_rotate_right (rt, z);
                  zp = rb_node (rt, z->parent);
                  zpp = rb_node (rt, zp->parent);
                }
              zp->color = RBTREE_BLACK;
              zpp->color = RBTREE_RED;
              rb_tree_rotate_left (rt, zpp);
            }
        }
    }
  rb_node (rt, rt->root)->color = RBTREE_BLACK;
}
 
static void
rb_tree_insert (rb_tree_t * rt, rb_node_t * z)
{
  rb_node_index_t yi = 0, xi = rt->root;
  rb_node_t *y, *x;
 
  y = rb_node (rt, RBTREE_TNIL_INDEX);
  while (xi != RBTREE_TNIL_INDEX)
    {
      x = rb_node (rt, xi);
      y = x;
      if (z->key < x->key)
        xi = x->left;
      else
        xi = x->right;
    }
  yi = rb_node_index (rt, y);
  z->parent = yi;
  if (yi == RBTREE_TNIL_INDEX)
    rt->root = rb_node_index (rt, z);
  else if (z->key < y->key)
    y->left = rb_node_index (rt, z);
  else
    y->right = rb_node_index (rt, z);
 
  /* Tree fixup stage */
  rb_tree_fixup_inline (rt, y, z);
}
 
__clib_export rb_node_index_t
rb_tree_add (rb_tree_t * rt, u32 key)
{
  rb_node_t *n;
 
  pool_get_zero (rt->nodes, n);
  n->key = key;
  n->color = RBTREE_RED;
  rb_tree_insert (rt, n);
  return rb_node_index (rt, n);
}
 
__clib_export rb_node_index_t
rb_tree_add2 (rb_tree_t * rt, u32 key, uword opaque)
{
  rb_node_t *n;
 
  pool_get_zero (rt->nodes, n);
  n->key = key;
  n->color = RBTREE_RED;
  n->opaque = opaque;
  rb_tree_insert (rt, n);
  return rb_node_index (rt, n);
}
 
__clib_export rb_node_index_t
rb_tree_add_custom (rb_tree_t * rt, u32 key, uword opaque, rb_tree_lt_fn ltfn)
{
  rb_node_index_t yi = 0, xi = rt->root;
  rb_node_t *z, *y, *x;
 
  pool_get_zero (rt->nodes, z);
  z->key = key;
  z->color = RBTREE_RED;
  z->opaque = opaque;
 
  y = rb_node (rt, RBTREE_TNIL_INDEX);
  while (xi != RBTREE_TNIL_INDEX)
    {
      x = rb_node (rt, xi);
      y = x;
      ASSERT (z->key != x->key);
      if (ltfn (z->key, x->key))
        xi = x->left;
      else
        xi = x->right;
    }
  yi = rb_node_index (rt, y);
  z->parent = yi;
  if (yi == RBTREE_TNIL_INDEX)
    rt->root = rb_node_index (rt, z);
  else if (ltfn (z->key, y->key))
    y->left = rb_node_index (rt, z);
  else
    y->right = rb_node_index (rt, z);
 
  rb_tree_fixup_inline (rt, y, z);
 
  return rb_node_index (rt, z);
}
 
__clib_export rb_node_t *
rb_tree_search_subtree (rb_tree_t * rt, rb_node_t * x, u32 key)
{
  while (rb_node_index (rt, x) != RBTREE_TNIL_INDEX && key != x->key)
    if (key < x->key)
      x = rb_node_left (rt, x);
    else
      x = rb_node_right (rt, x);
  return x;
}
 
__clib_export rb_node_t *
rb_tree_search_subtree_custom (rb_tree_t * rt, rb_node_t * x, u32 key,
                               rb_tree_lt_fn ltfn)
{
  while (rb_node_index (rt, x) != RBTREE_TNIL_INDEX && key != x->key)
    if (ltfn (key, x->key))
      x = rb_node_left (rt, x);
    else
      x = rb_node_right (rt, x);
  return x;
}
 
__clib_export rb_node_t *
rb_tree_min_subtree (rb_tree_t * rt, rb_node_t * x)
{
  while (x->left != RBTREE_TNIL_INDEX)
    x = rb_node_left (rt, x);
  return x;
}
 
__clib_export rb_node_t *
rb_tree_max_subtree (rb_tree_t * rt, rb_node_t * x)
{
  while (x->right != RBTREE_TNIL_INDEX)
    x = rb_node_right (rt, x);
  return x;
}
 
__clib_export rb_node_t *
rb_tree_successor (rb_tree_t * rt, rb_node_t * x)
{
  rb_node_t *y;
 
  if (x->right != RBTREE_TNIL_INDEX)
    return rb_tree_min_subtree (rt, rb_node_right (rt, x));
 
  y = rb_node_parent (rt, x);
  while (!rb_node_is_tnil (rt, y) && y->right == rb_node_index (rt, x))
    {
      x = y;
      y = rb_node_parent (rt, y);
    }
  return y;
}
 
__clib_export rb_node_t *
rb_tree_predecessor (rb_tree_t * rt, rb_node_t * x)
{
  rb_node_t *y;
 
  if (x->left != RBTREE_TNIL_INDEX)
    return rb_tree_max_subtree (rt, rb_node_left (rt, x));
 
  y = rb_node_parent (rt, x);
  while (!rb_node_is_tnil (rt, y) && y->left == rb_node_index (rt, x))
    {
      x = y;
      y = rb_node_parent (rt, y);
    }
  return y;
}
 
static inline void
rb_tree_transplant (rb_tree_t * rt, rb_node_t * u, rb_node_t * v)
{
  rb_node_t *up;
 
  up = rb_node_parent (rt, u);
  if (u->parent == RBTREE_TNIL_INDEX)
    rt->root = rb_node_index (rt, v);
  else if (rb_node_index (rt, u) == up->left)
    up->left = rb_node_index (rt, v);
  else
    up->right = rb_node_index (rt, v);
  v->parent = u->parent;
}
 
static void
rb_tree_del_node_internal (rb_tree_t * rt, rb_node_t * z)
{
  rb_node_color_t y_original_color;
  rb_node_t *x, *y, *yr, *yl, *xp, *w, *wl, *wr;
  rb_node_index_t xi, yi;
 
  y = z;
  y_original_color = y->color;
 
  if (z->left == RBTREE_TNIL_INDEX)
    {
      x = rb_node_right (rt, z);
      rb_tree_transplant (rt, z, x);
    }
  else if (z->right == RBTREE_TNIL_INDEX)
    {
      x = rb_node_left (rt, z);
      rb_tree_transplant (rt, z, x);
    }
  else
    {
      y = rb_tree_min_subtree (rt, rb_node_right (rt, z));
      y_original_color = y->color;
      x = rb_node_right (rt, y);
      yi = rb_node_index (rt, y);
      if (y->parent == rb_node_index (rt, z))
        x->parent = yi;
      else
        {
          rb_tree_transplant (rt, y, x);
          y->right = z->right;
          yr = rb_node_right (rt, y);
          yr->parent = yi;
        }
      rb_tree_transplant (rt, z, y);
      y->left = z->left;
      yl = rb_node_left (rt, y);
      yl->parent = yi;
      y->color = z->color;
    }
 
  if (y_original_color == RBTREE_RED)
    return;
 
  /* Tree fixup needed */
 
  xi = rb_node_index (rt, x);
  while (xi != rt->root && x->color == RBTREE_BLACK)
    {
      xp = rb_node_parent (rt, x);
      if (xi == xp->left)
        {
          w = rb_node_right (rt, xp);
          if (w->color == RBTREE_RED)
            {
              w->color = RBTREE_BLACK;
              xp->color = RBTREE_RED;
              rb_tree_rotate_left (rt, xp);
              w = rb_node_right (rt, xp);
            }
          wl = rb_node_left (rt, w);
          wr = rb_node_right (rt, w);
          if (wl->color == RBTREE_BLACK && wr->color == RBTREE_BLACK)
            {
              if (!rb_node_is_tnil (rt, w))
                w->color = RBTREE_RED;
              x = xp;
            }
          else
            {
              if (wr->color == RBTREE_BLACK)
                {
                  wl->color = RBTREE_BLACK;
                  w->color = RBTREE_RED;
                  rb_tree_rotate_right (rt, w);
                  w = rb_node_right (rt, xp);
                  wr = rb_node_right (rt, w);
                }
              w->color = xp->color;
              xp->color = RBTREE_BLACK;
              wr->color = RBTREE_BLACK;
              rb_tree_rotate_left (rt, xp);
              x = rb_node (rt, rt->root);
            }
        }
      else
        {
          w = rb_node_left (rt, xp);
          if (w->color == RBTREE_RED)
            {
              w->color = RBTREE_BLACK;
              xp->color = RBTREE_RED;
              rb_tree_rotate_right (rt, xp);
              w = rb_node_left (rt, xp);
            }
          wl = rb_node_left (rt, w);
          wr = rb_node_right (rt, w);
          if (wl->color == RBTREE_BLACK && wr->color == RBTREE_BLACK)
            {
              if (!rb_node_is_tnil (rt, w))
                w->color = RBTREE_RED;
              x = xp;
            }
          else
            {
              if (wl->color == RBTREE_BLACK)
                {
                  wr->color = RBTREE_BLACK;
                  w->color = RBTREE_RED;
                  rb_tree_rotate_left (rt, w);
                  w = rb_node_left (rt, xp);
                  wl = rb_node_left (rt, w);
                }
              w->color = xp->color;
              xp->color = RBTREE_BLACK;
              wl->color = RBTREE_BLACK;
              rb_tree_rotate_right (rt, xp);
              x = rb_node (rt, rt->root);
            }
        }
      xi = rb_node_index (rt, x);
    }
  x->color = RBTREE_BLACK;
}
 
__clib_export void
rb_tree_del_node (rb_tree_t * rt, rb_node_t * z)
{
  rb_tree_del_node_internal (rt, z);
  pool_put (rt->nodes, z);
}
 
__clib_export void
rb_tree_del (rb_tree_t * rt, u32 key)
{
  rb_node_t *n;
  n = rb_tree_search_subtree (rt, rb_node (rt, rt->root), key);
  if (rb_node_index (rt, n) != RBTREE_TNIL_INDEX)
    rb_tree_del_node (rt, n);
}
 
__clib_export void
rb_tree_del_custom (rb_tree_t * rt, u32 key, rb_tree_lt_fn ltfn)
{
  rb_node_t *n;
  n = rb_tree_search_subtree_custom (rt, rb_node (rt, rt->root), key, ltfn);
  if (rb_node_index (rt, n) != RBTREE_TNIL_INDEX)
    rb_tree_del_node (rt, n);
}
 
__clib_export u32
rb_tree_n_nodes (rb_tree_t * rt)
{
  return pool_elts (rt->nodes);
}
 
__clib_export void
rb_tree_free_nodes (rb_tree_t * rt)
{
  pool_free (rt->nodes);
  rt->root = RBTREE_TNIL_INDEX;
}
 
__clib_export void
rb_tree_init (rb_tree_t * rt)
{
  rb_node_t *tnil;
 
  rt->nodes = 0;
  rt->root = RBTREE_TNIL_INDEX;
 
  /* By convention first node, index 0, is the T.nil sentinel */
  pool_get_zero (rt->nodes, tnil);
  tnil->color = RBTREE_BLACK;
}
 
__clib_export int
rb_tree_is_init (rb_tree_t * rt)
{
  if (pool_elts (rt->nodes) == 0)
    return 0;
  return 1;
}
 
/*
 * fd.io coding-style-patch-verification: ON
 *
 * Local Variables:
 * eval: (c-set-style "gnu")
 * End:
 */