Lines Matching refs:right
52 #define right dict_right
78 * its right child C are rearranged so that the P instead becomes the left
79 * child of C. The left subtree of C is inherited as the new right subtree
86 lower = upper->right;
87 upper->right = lowleft = lower->left;
98 dict_assert(upper == upparent->right);
99 upparent->right = lower;
108 * the same procedure, but with left and right interchanged.
115 upper->left = lowright = lower->right;
120 if (upper == upparent->right) {
121 upparent->right = lower;
127 lower->right = upper;
140 free_nodes(dict, node->right, nil);
181 * be computed recursively and compared for left and right siblings for
193 height_right = verify_redblack(nil, root->right);
201 if (root->right->color != dnode_black)
223 + verify_node_count(nil, root->right);
238 || verify_dict_has_node(nil, root->right, node);
259 new->nilnode.right = &new->nilnode;
304 dict->nilnode.right = &dict->nilnode;
332 dict->nilnode.right = &dict->nilnode;
352 dict->nilnode.right = &dict->nilnode;
367 dict->nilnode.right = &dict->nilnode;
389 if (nil->right != nil)
411 int dict_similar(const dict_t *left, const dict_t *right)
413 if (left->compare != right->compare)
416 if (left->allocnode != right->allocnode)
419 if (left->freenode != right->freenode)
422 if (left->context != right->context)
425 if (left->dupes != right->dupes)
452 root = root->right;
461 root = root->right;
486 root = root->right;
520 root = root->right;
526 root = root->right;
564 where = where->right;
572 parent->right = node;
576 node->right = nil;
587 uncle = grandpa->right;
595 if (node == parent->right) {
606 } else { /* symmetric cases: parent == parent->parent->right */
650 * successor (i.e. the leftmost node in the right subtree.) By doing this,
660 if (delete->left != nil && delete->right != nil) {
671 * moving up its right child into its place.
674 child = next->right;
680 dict_assert(nextparent->right == next);
681 nextparent->right = child;
691 next->right = delete->right;
693 next->right->parent = next;
700 dict_assert(delparent->right == delete);
701 delparent->right = next;
706 dict_assert(delete->left == nil || delete->right == nil);
708 child = (delete->left != nil) ? delete->left : delete->right;
715 dict_assert(delete == delparent->right);
716 delparent->right = child;
721 delete->right = NULL;
738 sister = parent->right;
744 sister = parent->right;
748 && sister->right->color == dnode_black) {
752 if (sister->right->color == dnode_black) {
757 sister = parent->right;
761 sister->right->color = dnode_black;
766 } else { /* symmetric case: child == child->parent->right */
767 dict_assert(child == parent->right);
777 if (sister->right->color == dnode_black
783 dict_assert(sister->right->color == dnode_red);
784 sister->right->color = dnode_black;
854 dnode_t *nil = dict_nil(dict), *root = dict_root(dict), *right;
857 while ((right = root->right) != nil)
858 root = right;
865 * next key in the the left to right ordering. If the node has
873 if (curr->right != nil) {
874 curr = curr->right;
882 while (parent != nil && curr == parent->right) {
896 dnode_t *nil = dict_nil(dict), *parent, *right;
900 while ((right = curr->right) != nil)
901 curr = right;
964 new->right = NULL;
974 dnode->right = NULL;
1004 return (dnode->parent && dnode->left && dnode->right);
1027 load->nilnode.right = &load->nilnode;
1054 nil->right->left = newnode;
1055 nil->right = newnode;
1088 complete->right = dictnil;
1090 tree[level]->right = complete;
1100 curr->right = dictnil;
1106 tree[level]->right = complete;
1126 tree[i]->right = complete;
1133 dictnil->right = dictnil;