chooser::pitem chooser::splay(pitem p) { if (!p) { return nullptr; } while (p->parent) { if (!p->parent->parent) { if (is_left_child(p)) { right_rotale(p->parent); } else { left_rotale(p->parent); } } else if (is_left_child(p) ^ is_left_child(p->parent)) { if (is_left_child(p)) { right_rotale(p->parent); left_rotale(p->parent); } else { left_rotale(p->parent); right_rotale(p->parent); } } else { if (is_left_child(p)) { right_rotale(p->parent->parent); right_rotale(p->parent); } else { left_rotale(p->parent->parent); left_rotale(p->parent); } } } return p; }
chooser::pitem chooser::delete_element(pitem p) { pitem res = nullptr; if (!p->L && !p->R) { if (p->parent) { res = p->parent; if (is_left_child(p)) { res->L = nullptr; } else { res->R = nullptr; } } delete p; } else if (!p->L || !p->R) { if (p->parent) { res = p->parent; if (is_left_child(p)) { res->L = p->L ? p->L : p->R; } else { res->R = p->L ? p->L : p->R; } p->L = p->R = nullptr; delete p; } else { if (p->L) { right_rotale(p); } else { left_rotale(p); } return delete_element(p); } } else { pitem q = leftmost_child(p->R); if (q != p->R) { std::swap(p->L, q->L); std::swap(p->R, q->R); recalc(p); recalc(q); const pitem p_par = p->parent; make_parent(q->parent, p); make_parent(p_par, q); } else { left_rotale(p); } assert(!p->L || !p->R); delete_element(p); res = q->parent ? q->parent : q; } recalc(res); return splay(res); }
node_t *node_remove(node_t *n) { if (is_leaf(n)) { // przypadek 1: jest liściem // usuń wskaźnik z ojca if (is_left_child(n)) parent(n)->left = NULL; else parent(n)->right = NULL; } else if (has_one_child(n)) { // przypadek 2: tylko jedno dziecko node_t *child = (!is_nil(n->left)) ? (n->left) : (n->right); // niech dziadek stanie się ojcem parent(child) = parent(n); // podczep dziecko jako lewego lub prawego syna rodzica usuwanego węzła if (is_left_child(n)) parent(child)->left = child; else parent(child)->right = child; } else { // przypadek 3: dwoje dzieci // znajdź poprzednika node_t *next = n->left; while (!is_nil(next->right)) next = next->right; // zamień dane następnika z węzłem node_swap_data(next, n); n = node_remove(next); } n->left = NULL; n->right = NULL; parent(n) = NULL; return n; }
void node_rotate_left(tree_t *tree, node_t *x) { //printf("@rotate-left %d\n", x->key); node_t *y; y = x->right; x->right = y->left; if (!is_nil(y->left)) parent(y->left) = x; parent(y) = parent(x); if (is_nil(parent(x))) { tree->root = y; } else { if (is_left_child(x)) parent(x)->left = y; else parent(x)->right = y; } y->left = x; parent(x) = y; }
bool stateful_sequence::evaluate_true(cep_state* source, cep_state* target, tuple_ptr match) { universal_state* target2 = (universal_state*)target; if(is_left_child(source)) { // start a right-hand expression with match as context cep_state_ptr next = get_right_child()->create_state(match, target2); boost::any_cast<state_type_ptr>(target2->get_property("right_states"))->insert(next); return false; } else { if(selection == selection::FIRST) { if(boost::any_cast<bool>(target2->get_property("block"))) { // return first result and no more (block=false) target2->set_property("block", bool(false)); send_true(target, match); // selection = FIRST and consumption = ALL is faster // when we stop all child nodes immediately if(consumption == consumption::ALL) { boost::any_cast<state_type_ptr>(target2->get_property("right_states"))->clear(); } } } else { /* selection == selection::ALL */ send_true(target, match); } if(consumption == consumption::MATCHING) { boost::any_cast<state_type_ptr>(target2->get_property("right_states"))->erase(cep_state_ptr(target)); } } }
void rb_tree_insert_repair(tree_t *tree, node_t *n) { // przypadek 1: korzeń if (is_nil(parent(n))) { n->color = BLACK; return; } // przypadek 2: rodzic czarny if (parent(n)->color == BLACK) return; // przypadek 3: rodzic czerwony; wuj czerwony; if (!is_nil(uncle(n)) && uncle(n)->color == RED) { parent(n)->color = BLACK; uncle(n)->color = BLACK; grandparent(n)->color = RED; rb_tree_insert_repair(tree, grandparent(n)); } else // przypadek 4: rodzic czerwony; wuj czarny; { if (is_right_child(n) && is_left_child(parent(n))) { node_rotate_left(tree, parent(n)); n = n->left; } else if (is_left_child(n) && is_right_child(parent(n))) { node_rotate_right(tree, parent(n)); n = n->right; } // case 5: wuj czarny; nowy, rodzic, dziadek na prostej; nowy i rodzic czerwoni; parent(n)->color = BLACK; grandparent(n)->color = RED; if (is_left_child(n) && is_left_child(parent(n))) node_rotate_right(tree, grandparent(n)); else node_rotate_left(tree, grandparent(n)); } }
Bit side() const { if (is_left_child()) { return Bit::zero; } else { assert(is_right_child()); return Bit::one; } }
cowtree::editor::~editor () { if (!subtree_ptr->is_black()) { if (is_root()) { subtree_ptr->set_black(true); } else if (!parent_ptr->subtree_ptr->is_black()) { if (is_left_child() != parent_ptr->is_left_child()) { rotate(); } subtree_ptr->set_black(true); parent_ptr->rotate(); } } }
void cowtree::editor::rotate () { assert (!is_root()); if (is_left_child()) { parent_ptr->subtree_ptr->swap(subtree_ptr->right()); parent_ptr->subtree_ptr->swap(*subtree_ptr); subtree_ptr = &parent_ptr->subtree_ptr->right(); } else { parent_ptr->subtree_ptr->swap(subtree_ptr->left()); parent_ptr->subtree_ptr->swap(*subtree_ptr); subtree_ptr = &parent_ptr->subtree_ptr->left(); } assert (subtree_ptr != nullptr); }
node_t *rb_tree_remove_node(tree_t *tree, node_t *n) { node_t *c, *old_n = n; if (!is_nil(n->left) && !is_nil(n->right)) { // znajdź następnika node_t *next = n->right; while (!is_nil(next->left)) next = next->left; old_n = n; n = next; } c = (!is_nil(n->left)) ? (n->left) : (n->right); if (is_nil(c)) parent(c) = n; parent(c) = parent(n); if (is_nil(parent(n))) { tree->root = c; } else { if (is_left_child(n)) parent(n)->left = c; else parent(n)->right = c; } if (old_n != n) node_swap_data(old_n, n); if (n->color == BLACK) rb_tree_delete_repair(tree, c); n->left = NULL; n->right = NULL; parent(n) = NULL; return n; }
node_t* prev(node_t* node) { node_t* next_node = node; if (!is_root(node)) { while (is_left_child(next_node)) { next_node = next_node->parent; } } if (!is_root(next_node)) { next_node = next_node->parent->left; } while (next_node->right != NULL) { next_node = next_node->right; } return next_node; }
inline void chooser::right_rotale(pitem p) { assert(p->L); pitem q = p->L; if (p->parent) { if (is_left_child(p)) { p->parent->L = q; } else { p->parent->R = q; } } p->L = q->R; q->R = p; recalc(p->L); recalc(p); make_parent(p->parent, q); make_parent(q, p); recalc(q); recalc(q->parent); }
static struct rb_node *rb_sibling(struct rb_node *n) { if (is_left_child(n)) return n->parent->right; return n->parent->left; }
void rb_tree_delete_repair(tree_t *tree, node_t *n) { // przypadek 1: korzeń lub czerwony if (is_nil(parent(n)) || n->color == RED) return; // przypadek 2: if (sibling(n)->color == RED) { parent(n)->color = RED; sibling(n)->color = BLACK; if (is_left_child(n)) node_rotate_left(tree, parent(n)); else node_rotate_right(tree, parent(n)); } // przypadek 3: if (parent(n)->color == BLACK && sibling(n)->color == BLACK && sibling(n)->left->color == BLACK && sibling(n)->right->color == BLACK) { sibling(n)->color = RED; rb_tree_delete_repair(tree, parent(n)); return; } // przypadek 4: if (parent(n)->color == RED && sibling(n)->color == BLACK && sibling(n)->left->color == BLACK && sibling(n)->right->color == BLACK) { sibling(n)->color = RED; parent(n)->color = BLACK; return; } // przypadek 5 if (is_left_child(n) && sibling(n)->color == BLACK && sibling(n)->left->color == RED && sibling(n)->right->color == BLACK) { sibling(n)->color = RED; sibling(n)->left->color = BLACK; node_rotate_right(tree, sibling(n)); } else if (is_right_child(n) && sibling(n)->color == BLACK && sibling(n)->right->color == RED && sibling(n)->left->color == BLACK) { sibling(n)->color = RED; sibling(n)->right->color = BLACK; node_rotate_left(tree, sibling(n)); } // przypadek 6: sibling(n)->color = parent(n)->color; parent(n)->color = BLACK; if (is_left_child(n)) { sibling(n)->right->color = BLACK; node_rotate_left(tree, parent(n)); } else { sibling(n)->left->color = BLACK; node_rotate_right(tree, parent(n)); } }