/** * Balances red black trees. * @param t tree to balance. * @return balanced tree. */ static tree tree_fix(tree t) { if(IS_RED(t->left) && IS_RED(t->left->left)){ if(IS_RED(t->right)){ /*colour root red and children a,b black*/ t->colour = RED; t->left->colour = BLACK; t->right->colour = BLACK; }else if(IS_BLACK(t->right)){ /*right rotate root , colour new root (a) black, * and new child(old root) red*/ t = right_rotate(t); t->colour = BLACK; t->right->colour = RED;/*old root*/ } }else if(IS_RED(t->left) && IS_RED(t->left->right)){ if(IS_RED(t->right)){ /*colour root red and children a,b black*/ t->colour = RED; t->left->colour = BLACK; t->right->colour = BLACK; } else if(IS_BLACK(t->right)){ /* Left rotate left child (a), right rotate root (r), * colour new root (d) black and new child (R) red */ t->left = left_rotate(t->left); t = right_rotate(t); t->colour = BLACK; t->right->colour = RED;/* old root */ } }else if(IS_RED(t->right) && IS_RED(t->right->left)){ if(IS_RED(t->left)){ /* Colour root (R) red and children (a,b) black*/ t->colour = RED; t->left->colour = BLACK; t->right->colour = BLACK; }else if(IS_BLACK(t->left)){ /* Right rotate right child(b),left rotate root(r), * colour new root (e) black and new child (r) red */ t->right = right_rotate(t->right); t = left_rotate(t); t->colour = BLACK; t->left->colour = RED;/* old root */ } }else if(IS_RED(t->right) && IS_RED(t->right->right)){ if(IS_RED(t->left)){ /* Colour root (R) red and children (A,B) black */ t->colour = RED; t->left->colour = BLACK; t->right->colour = BLACK; } else if(IS_BLACK(t->left)){ /* Left rotate root R, colour new root b black and new child R red */ t = left_rotate(t); t->colour = BLACK; t->left->colour = RED;/*old root*/ } } return t; }
int maintain(int &t,int flag) { if (flag==0)// { if (SBT[SBT[SBT[t].left].left].s>SBT[SBT[t].right].s) right_rotate(t); else if (SBT[SBT[SBT[t].left].right].s>SBT[SBT[t].right].s) { left_rotate(SBT[t].left); right_rotate(t); } else return t; } else { if (SBT[SBT[SBT[t].right].right].s>SBT[SBT[t].left].s) left_rotate(t); else if (SBT[SBT[SBT[t].right].left].s>SBT[SBT[t].left].s) { right_rotate(SBT[t].right); left_rotate(t); } else return t; } maintain(SBT[t].left,0); maintain(SBT[t].right,1); maintain(t,0); maintain(t,1); return t; }
struct node *balance(struct node *t ) { unsigned int tmp ; unsigned int tmp___0 ; unsigned int tmp___1 ; unsigned int tmp___2 ; unsigned int tmp___3 ; unsigned int tmp___4 ; unsigned int tmp___5 ; unsigned int tmp___6 ; { tmp___5 = height(t->left); tmp___6 = height(t->right); if (tmp___5 > 1U + tmp___6) { tmp = height((t->left)->left); tmp___0 = height((t->left)->right); if (tmp < tmp___0) { t->left = left_rotate(t->left); } t = right_rotate(t); } else { tmp___3 = height(t->left); tmp___4 = height(t->right); if (tmp___3 + 1U < tmp___4) { tmp___1 = height((t->right)->left); tmp___2 = height((t->right)->right); if (tmp___1 > tmp___2) { t->right = right_rotate(t->right); } t = left_rotate(t); } } return (t); } }
/* rebalance_AVL: checks if the left and right branches of the tree are even, * if they are not. Check which rotation needs to be carried out and do it. * * Params: the AVL root node, and last value entered. * * Returns: a newly balanced tree if rebalancing is needed, or just returns * the current root if no balancing is necessary. */ static AVL rebalance_AVL(AVL self, int value) { int balance; /* update the height of the ancestor */ self->height = maximum(height(self->left), height(self->right)) + 1; /* check that the left and right subtrees are balanced. */ balance = check_balance(self); /* check for left rotate */ if (balance > 1 && value < self->student_id) { return right_rotate(self); } /* check for right rotate */ if (balance < -1 && value > self->student_id) { return left_rotate(self); } /* check for double rotate (left then right) */ if (balance > 1 && value > self->left->student_id) { self->left = left_rotate(self); return right_rotate(self); } /* check for double rotate (right then left) */ if (balance < -1 && value < self->right->student_id) { self->right = right_rotate(self); return left_rotate(self); } return self; }
/* Fixup the balance of the btree after deletion */ static void btree_delete_fixup(opal_rb_tree_t *tree, opal_rb_tree_node_t * x) { opal_rb_tree_node_t * w; opal_rb_tree_node_t * root = tree->root_ptr->left; while ((x != root) && (x->color == BLACK)) { if (x == x->parent->left) { w = x->parent->right; if (w->color == RED) { w->color = BLACK; x->parent->color = RED; left_rotate(tree, x->parent); w = x->parent->right; } if ((w->left->color == BLACK) && (w->right->color == BLACK)) { w->color = RED; x = x->parent; } else { if (w->right->color == BLACK) { w->left->color = BLACK; w->color = RED; right_rotate(tree, w); w = x->parent->right; } w->color = x->parent->color; x->parent->color = BLACK; w->right->color = BLACK; left_rotate(tree, x->parent); x = root; } } else { /* right */ w = x->parent->left; if (w->color == RED) { w->color = BLACK; x->parent->color = RED; right_rotate(tree, x->parent); w = x->parent->left; } if ((w->right->color == BLACK) && (w->left->color == BLACK)) { w->color = RED; x = x->parent; } else { if (w->left->color == BLACK) { w->right->color = BLACK; w->color = RED; left_rotate(tree, w); w = x->parent->left; } w->color = x->parent->color; x->parent->color = BLACK; w->left->color = BLACK; right_rotate(tree, x->parent); x = root; } } } x->color = BLACK; return; }
static void rb_delete_fixup(tree_p tr, tnode_p parent, tnode_p node){ tnode_p sibling; while(node != tr->root && rb_color(node) == BLACK){ if( node == parent->left ){ sibling = parent->right; if(rb_color(sibling) == RED){ sibling->color = BLACK; parent->color = RED; left_rotate(tr, parent); sibling = parent->right; } if(rb_color(sibling->left) == BLACK && rb_color(sibling->right) == BLACK){ sibling->color = RED; node = parent; parent = parent->parent; } else if(rb_color(sibling->right) == BLACK){ sibling->left->color = RED; right_rotate(tr, sibling); sibling = parent->right; } else { sibling->color = parent->color; parent->color = BLACK; sibling->right->color = BLACK; left_rotate(tr, parent); node = tr->root; parent = NULL; } } else{ sibling = parent->left; if(rb_color(sibling) == RED){ sibling->color = BLACK; parent->color = RED; right_rotate(tr, parent); sibling = parent->left; } if(rb_color(sibling->left) == BLACK && rb_color(sibling->right) == BLACK){ sibling->color = RED; node = parent; parent = parent->parent; } else if(rb_color(sibling->left) == BLACK){ sibling->right->color = RED; left_rotate(tr, sibling); sibling = parent->left; } else { sibling->color = parent->color; parent->color = BLACK; sibling->left->color = BLACK; right_rotate(tr, parent); node = tr->root; parent = NULL; } } } if(node != NULL) node->color = BLACK; }
void rb_tree<T>::remove_fixup(rb_vertex<T>* current_vertex) { // current_vertex is x in Corman // this is w in Corman rb_vertex<T>* child; while (current_vertex != root && current_vertex->get_colour() == BLACK) { if (current_vertex == current_vertex->get_parent()->get_left_child()) { child = current_vertex->get_parent()->get_right_child(); if (child->get_colour() == RED) { child.set_colour(BLACK); current_vertex->get_parent()->set_colour(RED); left_rotate(current_vertex->get_parent); child = current_vertex->get_parent->get_right_child(); } if (child->get_left_child()->get_colour() == BLACK && child->get_right_child()->get_colour() == BLACK) { child->set_colour(RED); current_vertex = current_vertex->get_parent(); } else { if (child->get_right_child()->get_colour() == BLACK) { child->get_left_child()->set_colour(BLACK); child->set_colour(RED); right_rotate(child); child = current_vertex->get_parent()->get_right_child(); } child->set_colour(current_vertex->get_parent()->get_colour()); current_vertex->get_parent()->set_colour(BLACK); child->get_right_child()->set_colour(BLACK); left_rotate(current_vertex->get_parent()); current_vertex = root; } } else { child = current_vertex->get_parent()->get_left_child(); if (child->get_colour() == RED) { child.set_colour(BLACK); current_vertex->get_parent()->set_colour(RED); right_rotate(current_vertex->get_parent); child = current_vertex->get_parent->get_left_child(); } if (child->get_left_child()->get_colour() == BLACK && child->get_right_child()->get_colour() == BLACK) { child->set_colour(RED); current_vertex = current_vertex->get_parent(); } else { if (child->get_left_child()->get_colour() == BLACK) { child->get_right_child()->set_colour(BLACK); child->set_colour(RED); left_rotate(child); child = current_vertex->get_parent()->get_left_child(); } child->set_colour(current_vertex->get_parent()->get_colour()); current_vertex->get_parent()->set_colour(BLACK); child->get_left_child()->set_colour(BLACK); right_rotate(current_vertex->get_parent()); current_vertex = root; } } } current_vertex->set_colour(BLACK); }
void RBTree::remove_fixup(rbnode * x) { while (x != root && x->color == BLACK) { rbnode * p = x->parent; if (x == p->lc) { // LEFT CHILD rbnode * w = p->rc; if (w->color == RED) { p->color = RED; w->color = BLACK; left_rotate(p); w = p->rc; } if (w->lc->color == BLACK && w->rc->color == BLACK) { w->color = RED; x = p; } else { if (w->rc->color == BLACK) { // w->rc is red w->color = RED; w->lc->color = BLACK; w = right_rotate(w); } w->color = p->color; p->color = BLACK; w->rc->color = BLACK; left_rotate(p); x = root; } } else { // right child rbnode * w = p->lc; if (w->color == RED) { p->color = RED; w->color = BLACK; right_rotate(p); w = p->lc; } if (w->lc->color == BLACK && w->rc->color == BLACK) { w->color = RED; x = p; } else { if (w->lc->color == BLACK) { // w->rc is red w->color = RED; w->rc->color = BLACK; w = left_rotate(w); } w->color = p->color; p->color = BLACK; w->lc->color = BLACK; right_rotate(p); x = root; } } } x->color = BLACK; }
void rb_delete_fixup(RB_TREE *T, RB_NODE *x) { RB_NODE *w; while (x != T->root && x->color == BLACK) { if (x == x->parent->left) { w = x->parent->right; if (w->color == RED) { w->color = BLACK; //case 1 x->parent->color = RED; //case 1 left_rotate(T, x->parent); //case 1 w = x->parent->right; //case 1 } if (w->left->color == BLACK && w->right->color == BLACK) { w->color = RED; //case 2 x = x->parent; //case 2 } else if (w->right->color == BLACK) { w->left->color = BLACK; //case 3 w->color = RED; //case 3 right_rotate(T, w); //case 3 w = x->parent->right; //case 3 } w->color = x->parent->color; //case 4 x->parent->color = BLACK; //case 4 w->right->color = BLACK; //case 4 left_rotate(T, x->parent); //case 4 x = T->root; //case 4 } else { if (x == x->parent->right) { w = x->parent->left; if (w->color == RED) { w->color = BLACK; x->parent->color = RED; right_rotate(T, x->parent); w = x->parent->left; } if (w->right->color == BLACK && w->left->color == BLACK) { w->color = RED; x = x->parent; } else if (w->left->color == BLACK) { w->right->color = BLACK; w->color = RED; left_rotate(T, w); w = x->parent->left; } w->color = x->parent->color; x->parent->color = BLACK; w->left->color = BLACK; right_rotate(T, x->parent); x = T->root; } } } x->color = BLACK; }
static rbt rbt_fix(rbt r) { if(IS_RED(r->left) && IS_RED(r->left->left)){ if(IS_RED(r->right)){ /*colour root red and children a,b black*/ r->colour = RED; r->left->colour = BLACK; r->right->colour = BLACK; }else if(IS_BLACK(r->right)){ /*right rotate root , colour new root (a) black, and new child(old root) red*/ r = right_rotate(r); r->colour = BLACK; r->right->colour = RED;/*old root?*/ } }else if(IS_RED(r->left) && IS_RED(r->left->right)){ if(IS_RED(r->right)){ /*colour root red and children a,b black*/ r->colour = RED; r->left->colour = BLACK; r->right->colour = BLACK; } else if(IS_BLACK(r->right)){ /*left rotate left child (a), right rotate root (r),colour new root (d) black and new child (R) red*/ r->left = left_rotate(r->left); r = right_rotate(r); r->colour = BLACK; r->right->colour = RED;/*old root?*/ } }else if(IS_RED(r->right) && IS_RED(r->right->left)){ if(IS_RED(r->left)){ /* colour root (R) red and children (a,b) black*/ r->colour = RED; r->left->colour = BLACK; r->right->colour = BLACK; }else if(IS_BLACK(r->left)){ /*right rotate right child(b),left rotate root(r),colour new root (e) black and new child (r) red*/ r->right = right_rotate(r->right); r = left_rotate(r); r->colour = BLACK; r->left->colour = RED;/*old root?*/ } }else if(IS_RED(r->right) && IS_RED(r->right->right)){ if(IS_RED(r->left)){ /*colour root (R) red and children (A,B) black*/ r->colour = RED; r->left->colour = BLACK; r->right->colour = BLACK; } else if(IS_BLACK(r->left)){ /*left rotate root R, colour new root b black and new child R red*/ r = left_rotate(r); r->colour = BLACK; r->left->colour = RED;/*old root?*/ } } return r; }
static void k_rbtree_delete_fixup(k_rbtree_t* t,k_rbnode_t* x) { k_rbnode_t* w;// w is x's brother while( (x != t->root)&& (x->color == k_color_black) ){ if(x == x->parent->left){ w = x->parent->right; if(w->color == k_color_red){ w->color = k_color_black; x->parent->color = k_color_red; left_rotate(t, x->parent); w = x->parent->left; } if(w->left->color == k_color_black && w->right->color == k_color_black){ w->color = k_color_red; x = x->parent; }else if (w->right->color == k_color_black){ w->left->color = k_color_black; w->color = k_color_red; right_rotate(t, w); w = x->parent->right; } w->color = x->parent->color; w->parent->color = k_color_black; left_rotate(t, x->parent); x = t->root; }else{//x == x->parent->right; w = x->parent->left; if(w->color == k_color_red){ w->color = k_color_black; x->parent->color = k_color_red; right_rotate(t,x->parent); w = x->parent->right; } if(w->right->color == k_color_black && w->left->color == k_color_black){ w->color = k_color_red; x = x->parent; }else if ( w->left->color = k_color_black){ w->right->color = k_color_black; w->color = k_color_red; left_rotate(t,w); w = w->parent->left; } w->color = x->parent->color; w->parent->color = k_color_black; right_rotate(t, x->parent); x = t->root; } } x->color = k_color_black; }
void _redblacktree::DeleteFixup(tree *x){ tree *w; while (x != root && x->color == black) { if (x == x->parent->left) { w = x->parent->right; if (w->color == red) { w->color = black; x->parent->color = red; left_rotate(x->parent); w = x->parent->right; } if (w->left->color == black && w->right->color == black) { w->color = red; x = x->parent; } else { if (w->right->color == black) { w->left->color = black; w->color = red; right_rotate(w); w = x->parent->right; } w->color = x->parent->color; x->parent->color =black; w->right->color = black; left_rotate(x->parent); x = root; } } else { w = x->parent->right; if (w->color == red) { w->color = black; x->parent->color = red; right_rotate(x->parent); w = x->parent->left; } if (w->right->color == black && w->left->color == black) { w->color = red; x = x->parent; } else { if (w->left->color == black) { w->right->color = black; w->color = red; left_rotate(w); w = x->parent->left; } w->color = x->parent->color; x->parent->color =black; w->left->color = black; right_rotate(x->parent); x = root; } } } x->color = black; }
void rb_delete_fixup(rbt *T, rbn *x) { rbn *w, *y; while (x != T->root && x->color == BLACK) { if (x == x->p->left) { w = x->p->right; if (w->color == RED) { w->color = BLACK; x->p->color = RED; left_rotate(T, x->p); w = x->p->right; } if (w->left->color == BLACK && w->right->color == BLACK) { w->color = RED; x = x->p; } else { if (w->right->color == BLACK) { w->left->color = BLACK; w->color = RED; right_rotate(T, w); w = x->p->right; } w->color = x->p->color; x->p->color = BLACK; w->right->color = BLACK; left_rotate(T, x->p); x = T->root; } } else { w = x->p->left; if (w->color == RED) { w->color = BLACK; x->p->color = RED; right_rotate(T, x->p); w = x->p->left; } if (w->left->color == BLACK && w->right->color == BLACK) { w->color = RED; x = x->p; } else { /*dbg(x, w);*/ if (w->left->color == BLACK) { w->right->color = BLACK; w->color = RED; left_rotate(T, w); w = x->p->left; } w->color = x->p->color; x->p->color = BLACK; w->left->color = BLACK; right_rotate(T, x->p); x = T->root; } } } }
static void delete_fixup(struct rbtree *rbt, struct rbnode *nd) { struct rbnode *tmp = &rbt->nil; while (nd != rbt->root && nd->color == BLACK) if (nd == nd->parent->left) { tmp = nd->parent->right; if (tmp->color == RED) { tmp->color = BLACK; nd->parent->color = RED; left_rotate(rbt, nd->parent); tmp = nd->parent->right; } if (tmp->left->color == BLACK && tmp->right->color == BLACK) { tmp->color = RED; nd = nd->parent; } else { if (tmp->right->color == BLACK) { tmp->left->color = BLACK; tmp->color = RED; right_rotate(rbt, tmp); tmp = nd->parent->right; } tmp->color = nd->parent->color; nd->parent->color = BLACK; tmp->right->color = BLACK; left_rotate(rbt, nd->parent); nd = rbt->root; //end while } } else { tmp = nd->parent->left; if (tmp->color == RED) { tmp->color = BLACK; nd->parent->color = RED; right_rotate(rbt, nd->parent); tmp = nd->parent->left; } if (tmp->right->color == BLACK && tmp->left->color == BLACK) { tmp->color = RED; nd = nd->parent; } else { if (tmp->left->color == BLACK) { tmp->right->color = BLACK; tmp->color = RED; left_rotate(rbt, tmp); tmp = nd->parent->left; } tmp->color = nd->parent->color; nd->parent->color = BLACK; tmp->left->color = BLACK; right_rotate(rbt, nd->parent); nd = rbt->root; //end while } } nd->color = BLACK; }
void SplayTree<T>::splay(SplayNode<T> *x, SplayNode<T> *y) { while(x->father != y) { SplayNode<T> * p = x->father; if (p->father == y) { // 因为p的父亲是y,所以只需要Zig操作,就可以使得x的父亲变成y if (p->left == x) { right_rotate(x); } else { left_rotate(x); } } else { SplayNode<T> * g = p->father; if (g->left == p) { if (p->left == x) { // x, p同为左儿子,zig-zig操作 right_rotate(p); right_rotate(x); } else { //p为左, x为右,zig-zag操作 left_rotate(x); right_rotate(x); } } else { if (p->right == x) { // x, p同为右儿子,zig-zig操作 left_rotate(p); left_rotate(x); } else { //p为右, x为左,zig-zag操作 right_rotate(x); left_rotate(x); } } } } }
static void bbtree_insert_fixup( bbtree_t *tree, bbtree_node_t *node ) { bbtree_node_t *node2; bbtree_node_t *nil = &tree->nil; while (node != tree->root && node->parent->colour == BBTREE_RED) { if (node->parent == node->parent->parent->left) { node2 = node->parent->parent->right; if (node2 != nil && node2->colour == BBTREE_RED) { node->parent->colour = BBTREE_BLACK; node2->colour = BBTREE_BLACK; node->parent->parent->colour = BBTREE_RED; node = node->parent->parent; } else { if (node == node->parent->right) { node = node->parent; left_rotate( tree, node ); } node->parent->colour = BBTREE_BLACK; node->parent->parent->colour = BBTREE_RED; right_rotate( tree, node->parent->parent ); } } else { node2 = node->parent->parent->left; if (node2 != nil && node2->colour == BBTREE_RED) { node->parent->colour = BBTREE_BLACK; node2->colour = BBTREE_BLACK; node->parent->parent->colour = BBTREE_RED; node = node->parent->parent; } else { if (node == node->parent->left) { node = node->parent; right_rotate( tree, node ); } node->parent->colour = BBTREE_BLACK; node->parent->parent->colour = BBTREE_RED; left_rotate( tree, node->parent->parent ); } } } tree->root->colour = BBTREE_BLACK; }
/*rbtree_delete_fixup*/ static inline void rbtree_delete_fixup(mln_sarbt_t *t, mln_sarbt_node_t *n) { mln_sarbt_node_t *tmp; while ((n != t->root) && (n->color == M_SARB_BLACK)) { if (n == n->parent->left) { tmp = n->parent->right; if (tmp->color == M_SARB_RED) { tmp->color = M_SARB_BLACK; n->parent->color = M_SARB_RED; left_rotate(t, n->parent); tmp = n->parent->right; } if ((tmp->left->color == M_SARB_BLACK) && (tmp->right->color == M_SARB_BLACK)) { tmp->color = M_SARB_RED; n = n->parent; continue; } else if (tmp->right->color == M_SARB_BLACK) { tmp->left->color = M_SARB_BLACK; tmp->color = M_SARB_RED; right_rotate(t, tmp); tmp = n->parent->right; } tmp->color = n->parent->color; n->parent->color = M_SARB_BLACK; tmp->right->color = M_SARB_BLACK; left_rotate(t, n->parent); n = t->root; } else { tmp = n->parent->left; if (tmp->color == M_SARB_RED) { tmp->color = M_SARB_BLACK; n->parent->color = M_SARB_RED; right_rotate(t, n->parent); tmp = n->parent->left; } if ((tmp->right->color == M_SARB_BLACK) && (tmp->left->color == M_SARB_BLACK)) { tmp->color = M_SARB_RED; n = n->parent; continue; } else if (tmp->left->color == M_SARB_BLACK) { tmp->right->color = M_SARB_BLACK; tmp->color = M_SARB_RED; left_rotate(t, tmp); tmp = n->parent->left; } tmp->color = n->parent->color; n->parent->color = M_SARB_BLACK; tmp->left->color = M_SARB_BLACK; right_rotate(t, n->parent); n = t->root; } } n->color = M_SARB_BLACK; }
void fix_rb_tree(struct node **root, struct node *z) { struct node *y; while(z->parent->color == RED) { if(z->parent == z->parent->parent->left) { y = z->parent->parent->right; if(y != NIL && y->color == RED) { //Case 1.1 z->parent->color = y->color = BLACK; z->parent->parent->color = RED; z = z->parent->parent; } else //Segmentation fault should come { if(z == z->parent->right) { //Case 1.2 z = z->parent; left_rotate(root, z); } //Case 1.3 z->parent->color = BLACK; z->parent->parent->color = RED; right_rotate(root, z->parent->parent); } } else { y = z->parent->parent->left; if(y != NIL && y->color == RED) { //Case 2.1 z->parent->color = y->color = BLACK; z->parent->parent->color = RED; z = z->parent->parent; } else { if(z == z->parent->left) { //Case 2.2 z = z->parent; right_rotate(root, z); } z->parent->color = BLACK; z->parent->parent->color = RED; left_rotate(root, z->parent->parent); } } } (*root)->color = BLACK; }
void RB::rb_balance(rb_node *x) { x->color = rb_red; while (x != root && x->parent->color == rb_red) { rb_node *y = 0; if (x->parent == x->parent->parent->left) { y = x->parent->parent->right; if (y && y->color == rb_red) { y->color = rb_black; x->parent->parent->color = rb_red; x->parent->color = rb_black; x = x->parent->parent; } else { if (x == x->parent->right) { x = x->parent; left_rotate(x); } x->parent->color = rb_black; x->parent->parent->color = rb_red; right_rotate(x->parent->parent); } } else { y = x->parent->parent->left; if (y && y->color == rb_red) { y->color = rb_black; x->parent->color = rb_black; x->parent->parent->color = rb_red; x = x->parent->parent; } else { if (x == x->parent->left) { x = x->parent; right_rotate(x); } x->parent->color = rb_black; x->parent->parent->color = rb_red; left_rotate(x->parent->parent); } } } root->color = rb_black; }
void RBTree::rb_insert_fixup(Node *nd) { Node *y; while(nd->parent->color == RED) { if(nd->parent == nd->parent->parent->left) { y = nd->parent->parent->right; if(y->color == RED)//右叔叔是RED { nd->parent->color = BLACK; y->color = BLACK; nd->parent->parent->color = RED; nd = nd->parent->parent; } else //右叔叔是BLANK { if(nd == nd->parent->right) { nd = nd->parent; left_rotate(nd); } nd->parent->color = BLACK; nd->parent->parent->color = RED; right_rotate(nd->parent->parent); } } else { y = nd->parent->parent->left; if(y->color == RED)//左叔叔是RED { y->color = BLACK; nd->parent->color = BLACK; nd->parent->parent->color = RED; nd = nd->parent->parent; } else //左叔叔是BLANK { if(nd == nd->parent->left) { nd = nd->parent; right_rotate(nd); } nd->parent->color = BLACK; nd->parent->parent->color = RED; left_rotate(nd->parent->parent); } } } root->color = BLACK; }
void rb_insert_fixup(Node* &T, Node *n) { // 如果n的父亲是红色,则需要调整 // 如果n的父亲是黑色,则不需要调整,因为n本身是红色 while(IS_RED(PARENT(n))) { // 根据n的叔叔节点的颜色,来决定调整方案 Node *p = IS_LEFT(PARENT(n))? RIGHT(PARENT(PARENT(n))): LEFT(PARENT(PARENT(n))); // 如果叔叔是红色,那很简单,把爷爷的黑色转移给父亲和叔叔,爷爷刷成红色 // 这样,即满足了性质4,也没有破坏性质5及其他性质 // 但是,爷爷可能破坏了红黑性质4,则从爷爷开始继续调整(向上递归了两层) if (IS_RED(p)) { // 父亲刷成黑色 SET_BLACK(PARENT(n)); // 叔叔刷成黑色 SET_BLACK(p); // 爷爷刷成红色 SET_RED(PARENT(PARENT(n))); // 从爷爷开始继续调整 n = PARENT(PARENT(n)); continue; } // 如果叔叔是黑色,就复杂一点,引入旋转操作 // 如果n是左孩子,那么需要一次右旋+颜色调整即可 // 如果n是右孩子,则通过一次左旋调整成左孩子,然后按上面情况处理 if (IS_LEFT(PARENT(n))) { // 如果n是右孩子,通过右旋调整成左孩子 if (IS_RIGHT(n)) { n = PARENT(n); left_rotate(T, n); } // 现在n是左孩子了 SET_BLACK(PARENT(n)); SET_RED(PARENT(PARENT(n))); right_rotate(T, PARENT(PARENT(n))); } else { if (IS_LEFT(n)) { n = PARENT(n); right_rotate(T,n); } SET_BLACK(PARENT(n)); SET_RED(PARENT(PARENT(n))); left_rotate(T,PARENT(PARENT(n))); } } // 如果n是根节点,则把根设置为黑色 if (NIL == PARENT(n)) SET_BLACK(n); }
Node* avl_insert(int k, Node* tree){ /* Lisää uuden solmun puuhun. */ if (tree == NULL){ tree = memory_allocate(tree); tree->key = k; tree->ptrLeft = NULL; tree->ptrRight = NULL; } /* Vasempaan haaraan lisääminen. */ else if (tree->key > k){ if (tree->ptrLeft == NULL) printf("Arvo %d asetetaan solmun %d vasemmanpuoleiseksi lapseksi.\n", k, tree->key); tree->ptrLeft = avl_insert(k, tree->ptrLeft); /* tasapainottaminen: */ if(get_height(tree->ptrLeft) == get_height(tree->ptrRight)+ 2){ if(k < tree->ptrLeft->key){ tree = right_rotate(tree); printf("R-rotaatio\n"); } else{ tree->ptrLeft = left_rotate(tree->ptrLeft); tree = right_rotate(tree); printf("LR-rotaatio\n"); } } } /* Oikeaan haaraan lisääminen */ else if (tree->key < k){ if (tree->ptrRight == NULL) printf("Arvo %d asetetaan solmun %d oikeanpuoleiseksi lapseksi.\n", k, tree->key); tree->ptrRight = avl_insert(k, tree->ptrRight); /* tasapainottaminen: */ if (get_height(tree->ptrRight) == get_height(tree->ptrLeft) + 2){ /* R-rotaatio */ if (k > tree->ptrRight->key){ tree = left_rotate(tree); printf("L-rotaatio\n"); } else{ /* RL-rotaatio */ tree->ptrRight = right_rotate(tree->ptrRight); tree = left_rotate(tree); printf("RL-rotaatio\n"); } } } else{ printf("Arvo on jo aikaisemmin lisätty puuhun!\n"); } /* Korjataan solmum korkeus. */ tree->height = max(get_height(tree->ptrLeft), get_height(tree->ptrRight)) + 1; return (tree); }
void rb_insert_fix(node* x) { node_list y; while(x->p==red) { if(((x->p)->p)->left==(x->p)) { y=((x->p)->p)->right; if(y->color==RED) { y->color=BLACK; (x->p)->color=BLACK; ((x->p)->p)->color=RED; x=(x->p)->p; } else if(x==(x->p)->right) { x=x.p; left_rotate(x); } else { (x->p)->color=BALCKk; ((x->p)->p)->color=RED; right_rotate(((x->p)->p)); } } else { y=((x->p)->p)->left; if(y->color==RED) { y->color=BLACK; (y->p)->color=RED; (x->p)->color=BLACK; x=(x->p)->P; } else if(x==(x->p)->left) { x=x->p; right_rotate(x); } else { (x->p)->color=BLACK; ((x->p)->p)->color=RED; left_rotate(((x->p)->p)); } } } }
inline void sha1::process_block() { unsigned int w[80]; for (std::size_t i=0; i<16; ++i) { w[i] = (block_[i*4 + 0] << 24); w[i] |= (block_[i*4 + 1] << 16); w[i] |= (block_[i*4 + 2] << 8); w[i] |= (block_[i*4 + 3]); } for (std::size_t i=16; i<80; ++i) { w[i] = left_rotate((w[i-3] ^ w[i-8] ^ w[i-14] ^ w[i-16]), 1); } unsigned int a = h_[0]; unsigned int b = h_[1]; unsigned int c = h_[2]; unsigned int d = h_[3]; unsigned int e = h_[4]; for (std::size_t i=0; i<80; ++i) { unsigned int f; unsigned int k; if (i<20) { f = (b & c) | (~b & d); k = 0x5A827999; } else if (i<40) { f = b ^ c ^ d; k = 0x6ED9EBA1; } else if (i<60) { f = (b & c) | (b & d) | (c & d); k = 0x8F1BBCDC; } else { f = b ^ c ^ d; k = 0xCA62C1D6; } unsigned temp = left_rotate(a, 5) + f + e + k + w[i]; e = d; d = c; c = left_rotate(b, 30); b = a; a = temp; } h_[0] += a; h_[1] += b; h_[2] += c; h_[3] += d; h_[4] += e; }
static void insert_fixup( pj_rbtree *tree, pj_rbtree_node *node ) { pj_rbtree_node *temp, *parent; PJ_CHECK_STACK(); while (node != tree->root && node->parent->color == PJ_RBCOLOR_RED) { parent = node->parent; if (parent == parent->parent->left) { temp = parent->parent->right; if (temp->color == PJ_RBCOLOR_RED) { temp->color = PJ_RBCOLOR_BLACK; node = parent; node->color = PJ_RBCOLOR_BLACK; node = node->parent; node->color = PJ_RBCOLOR_RED; } else { if (node == parent->right) { node = parent; left_rotate(tree, node); } temp = node->parent; temp->color = PJ_RBCOLOR_BLACK; temp = temp->parent; temp->color = PJ_RBCOLOR_RED; right_rotate( tree, temp); } } else { temp = parent->parent->left; if (temp->color == PJ_RBCOLOR_RED) { temp->color = PJ_RBCOLOR_BLACK; node = parent; node->color = PJ_RBCOLOR_BLACK; node = node->parent; node->color = PJ_RBCOLOR_RED; } else { if (node == parent->left) { node = parent; right_rotate(tree, node); } temp = node->parent; temp->color = PJ_RBCOLOR_BLACK; temp = temp->parent; temp->color = PJ_RBCOLOR_RED; left_rotate(tree, temp); } } } tree->root->color = PJ_RBCOLOR_BLACK; }
static void k_rbtree_insert_fixup(k_rbtree_t* t,k_rbnode_t* z) { k_rbnode_t* y = K_NULL; while(z->parent->color == k_color_red) { if(z->parent == z->parent->parent->left) { y = z->parent->parent->right; if(y->color == k_color_red)//case 1 { z->parent->color = k_color_black; y->color = k_color_black; z->parent->parent->color = k_color_red; z = z->parent->parent; }else{ if(z == z->parent->right){//case 2 z = z->parent; left_rotate(t,z); } //case 2 will turn to case 3 z->parent->color = k_color_black;//case 3 z->parent->parent->color = k_color_red; right_rotate(t,z->parent->parent); } }else{ y = z->parent->parent->left; if(y->color == k_color_red)//case 1 { z->parent->color = k_color_black; y->color = k_color_black; z->parent->parent->color = k_color_red; z = z->parent->parent; }else{ if(z == z->parent->left){//case 2 z = z->parent; right_rotate(t,z); } z->parent->color = k_color_black;//case 3 z->parent->parent->color = k_color_red; left_rotate(t,z->parent->parent); } } } t->root->color = k_color_black; }
void interval_insert_fixup(INT_TREE tree, INT_NODE node) { while(node -> parent != NULL && node -> parent -> color == RED) { if(node -> parent == node -> parent -> parent -> left) { INT_NODE node_uncle = node -> parent -> parent -> right; // uncle's node if(node_uncle != NULL && node_uncle -> color == RED) // case 1 { node -> parent -> color = BLACK; node_uncle -> color = BLACK; node -> parent -> parent -> color = RED; node = node -> parent -> parent; }else { if(node == node -> parent -> right) // case 2: uncle is black, parent's right child { node = node -> parent; left_rotate(tree, node); } // turn to case 3 node -> parent -> color = BLACK; node -> parent -> parent -> color = RED; right_rotate(tree, node -> parent -> parent); } }else { INT_NODE node_uncle = node -> parent -> parent -> left; if(node_uncle != NULL && node_uncle -> color == RED) { node -> parent -> color = BLACK; node_uncle -> color = BLACK; node -> parent -> parent -> color = RED; node = node -> parent -> parent; }else { if(node == node -> parent -> left) { node = node -> parent; right_rotate(tree, node); } node -> parent -> color = BLACK; node -> parent -> parent -> color = RED; left_rotate(tree, node -> parent -> parent); } } } tree -> root -> color = BLACK; }
/* As we add a new node with color red, * if color of its parent is red too, * we need to resolve the additional red color. * We make it by considering the following 3 cases : * * 1. When z's uncle is red too,so both z's parent and z's uncle is red. * In this case, we simply color z's parent and z's uncle to black, * and color z's grand-parent from black to red. * Now there's no violation between z and its parent. * The node that may cause violation goes to z's grand-parent, * who is colored from black to red.So we start a new loop with z=p(p(z)). * * 2. If z's uncle is black,we cannot simply do as the case above. * Considering our goal to resolve the additional red color, * we may make it by some rotation and the red color will finally go * to z's uncle's side.As z's uncle is black,it will be okay for its uncle. * Mention that we may need more than one rotation to make it. * Here we only consider the case of p(z) == l(p(p(z))), * which is symmetric with the case of p(z) == r(p(p(z))). * Now we only condiser the first case,and there are two subcases for each one: * * 2.1 When z is right child of its parent ( z == r(p(z)) ). * We do the following : * z = p(z); * left-rotate(T,z); * After then,z and p(z) will still be red,which is still violating the rule. * But z now becomes left child of its parent,which is next case we will consider. * * 2.2 When z is left child of its parent ( z == l(p(z)) ). * We do the following : * c(p(z)) = RBT_BLACK; * c(p(p(z))) = RBT_RED; * right_rotate(T,p(p(z))); * We paint p(z) to black and p(p(z)) to red,and do the right rotateo on p(p(z)), * after then the additional red color goes to z's uncle's side and * the black-height property will stay unchanged. * * PS:ROTATE WILL NOT CHANGE THE BLACK-HEIGHT PROPERTY. * * FINALLY,WE SHOULD SET THE ROOT TO BLACK TO MAKE SURE WHEN THE FIRST NODE IS INSERTED, * IT WILL BE TRE ROOT AND BE BLACK. * */ static void rbt_insert_fixup(redBlackTree_t *T,rb_node_t * z) { rb_node_t * y; while(c(p(z)) == RBT_RED){ /* p(z) not null and color is red, * so p(z) is not root --> p(p(z)) exists * and c(p(p(z))) is RBT_BLACK */ if(p(z) == l(p(p(z)))){ /* p(z) is left child of its parent */ y = r(p(p(z))); /*------------- case 1 --------------*/ if(c(y) == RBT_RED){ /* p(z) 's parent must be black! */ c(y) = RBT_BLACK; c(p(z)) = RBT_BLACK; c(p(p(z))) = RBT_RED; z = p(p(z)); /*------------- case 2 --------------*/ }else if(z == r(p(z))){ /* y == NIL_NODE or c(y) is black */ z = p(z); left_rotate(T,z); /*------------- case 3 --------------*/ }else{ /* z is left child of its parent */ c(p(z)) = RBT_BLACK; c(p(p(z))) = RBT_RED; right_rotate(T,p(p(z))); } }else{ /* p(z) is right child of its parent */ y = l(p(p(z))); if(c(y) == RBT_RED){ c(y) = RBT_BLACK; c(p(z)) = RBT_BLACK; c(p(p(z))) = RBT_RED; z = p(p(z)); }else if(z == l(p(z))){ z = p(z); right_rotate(T,z); }else{ c(p(z)) = RBT_BLACK; c(p(p(z))) = RBT_RED; left_rotate(T,p(p(z))); } } } c(T->root) = RBT_BLACK; }
static void insert_fixup(struct rbtree * tree, struct rbtree_node * z) { assert(z->parent != NULL); while(z->parent->color == RBTREE_RED) { if(z->parent == z->parent->parent->left) { struct rbtree_node * y = z->parent->parent->right; if(y->color == RBTREE_RED) { z->parent->color = RBTREE_BLACK; y->color = RBTREE_BLACK; z->parent->parent->color = RBTREE_RED; z = z->parent->parent; } else { if(z == z->parent->right) { z = z->parent; left_rotate(tree, z); } z->parent->color = RBTREE_BLACK; z->parent->parent->color = RBTREE_RED; right_rotate(tree, z->parent->parent); } } else { struct rbtree_node * y = z->parent->parent->left; if(y->color == RBTREE_RED) { z->parent->color = RBTREE_BLACK; y->color = RBTREE_BLACK; z->parent->parent->color = RBTREE_RED; z = z->parent->parent; } else { if(z == z->parent->left) { z = z->parent; right_rotate(tree, z); } z->parent->color = RBTREE_BLACK; z->parent->parent->color = RBTREE_RED; left_rotate(tree, z->parent->parent); } } } tree->root->color = RBTREE_BLACK; }
struct node * balance(struct node *tree) { if (height(tree->left) - height(tree->right) > 1) { if (height(tree->left->left) < height(tree->left->right)) tree->left = left_rotate(tree->left); tree = right_rotate(tree); } else if (height(tree->left) - height(tree->right) < -1) { if (height(tree->right->left) > height(tree->right->right)) tree->right = right_rotate(tree->right); tree = left_rotate(tree); } return tree; }