static void mk_new_int(Rb_node l, Rb_node r, Rb_node p, int il)
{
Rb_node newnode;
newnode = (Rb_node) malloc(sizeof(struct rb_node));
setint(newnode);
setred(newnode);
setnormal(newnode);
newnode->c.child.left = l;
newnode->c.child.right = r;
newnode->p.parent = p;
newnode->k.lext = l;
newnode->v.rext = r;
l->p.parent = newnode;
r->p.parent = newnode;
setleft(l);
setright(r);
if (ishead(p)) {
p->p.root = newnode;
setroot(newnode);
} else if (il) {
setleft(newnode);
p->c.child.left = newnode;
} else {
setright(newnode);
p->c.child.right = newnode;
}
recolor(newnode);
}
static void mk_new_int(JRB l, JRB r, JRB p, int il)
{
JRB newnode;
newnode = (JRB) calloc(1, sizeof(struct jrb_node));
setint(newnode);
setred(newnode);
setnormal(newnode);
newnode->flink = l;
newnode->blink = r;
newnode->parent = p;
setlext(newnode, l);
setrext(newnode, r);
l->parent = newnode;
r->parent = newnode;
setleft(l);
setright(r);
if (ishead(p)) {
p->parent = newnode;
setroot(newnode);
} else if (il) {
setleft(newnode);
p->flink = newnode;
} else {
setright(newnode);
p->blink = newnode;
}
recolor(newnode);
}
void insert(NODEPTR *tree){
NODEPTR p,q;
int key;
printf("\nEnter the keys");
scanf("%d",&key);
while(key != EOF){
p=NULL;q=*tree;
while(q!=NULL){
p=q;
if(key<=p->key)
q=p->left;
else
q=p->right;
}/*End of inner while*/
if(p==NULL){
*tree=maketree(key);
}else if(key<=p->key){
setleft(p,key);
}
else setright(p,key);
scanf("%d",&key);
}/*end of outer while*/
}/*end of insert function*/
static void single_rotate(JRB y, int l)
{
int rl, ir;
JRB x, yp;
char *tmp;
ir = isroot(y);
yp = y->parent;
if (!ir) {
rl = isleft(y);
}
if (l) {
x = y->flink;
y->flink = x->blink;
setleft(y->flink);
y->flink->parent = y;
x->blink = y;
setright(y);
}
else {
x = y->blink;
y->blink = x->flink;
setright(y->blink);
y->blink->parent = y;
x->flink = y;
setleft(y);
}
x->parent = yp;
y->parent = x;
if (ir) {
yp->parent = x;
setnormal(y);
setroot(x);
}
else {
if (rl) {
yp->flink = x;
setleft(x);
}
else {
yp->blink = x;
setright(x);
}
}
}
static void single_rotate(Rb_node y, int l)
{
int rl, ir;
Rb_node x, yp;
ir = isroot(y);
yp = y->p.parent;
if (!ir) {
rl = isleft(y);
}
if (l) {
x = y->c.child.left;
y->c.child.left = x->c.child.right;
setleft(y->c.child.left);
y->c.child.left->p.parent = y;
x->c.child.right = y;
setright(y);
} else {
x = y->c.child.right;
y->c.child.right = x->c.child.left;
setright(y->c.child.right);
y->c.child.right->p.parent = y;
x->c.child.left = y;
setleft(y);
}
x->p.parent = yp;
y->p.parent = x;
if (ir) {
yp->p.root = x;
setnormal(y);
setroot(x);
} else {
if (rl) {
yp->c.child.left = x;
setleft(x);
} else {
yp->c.child.right = x;
setright(x);
}
}
}
void BST::insert(int x)
{
if (!_root) { _root = new BSTNode(x); return; }
auto p = _root;
while (p&&p->data() != x)
{
if (p->data()>x)
{
if (!p->left()){
p->setleft(new BSTNode(x)); break;
}
else p = p->left();
}
else
{
if (!p->right()){
p->setright(new BSTNode(x)); break;
}
else p = p->right();
}
}
}
void jrb_delete_node(JRB n)
{
JRB s, p, gp;
char ir;
if (isint(n)) {
fprintf(stderr, "Cannot delete an internal node: 0x%p\n", (void *)n);
exit(1);
}
if (ishead(n)) {
fprintf(stderr, "Cannot delete the head of an jrb_tree: 0x%p\n", (void *)n);
exit(1);
}
delete_item(n); /* Delete it from the list */
p = n->parent; /* The only node */
if (isroot(n)) {
p->parent = p;
free(n);
return;
}
s = sibling(n); /* The only node after deletion */
if (isroot(p)) {
s->parent = p->parent;
s->parent->parent = s;
setroot(s);
free(p);
free(n);
return;
}
gp = p->parent; /* Set parent to sibling */
s->parent = gp;
if (isleft(p)) {
gp->flink = s;
setleft(s);
} else {
gp->blink = s;
setright(s);
}
ir = isred(p);
free(p);
free(n);
if (isext(s)) { /* Update proper rext and lext values */
p = lprev(s);
if (!ishead(p)) setrext(p, s);
p = rprev(s);
if (!ishead(p)) setlext(p, s);
} else if (isblack(s)) {
fprintf(stderr, "DELETION PROB -- sib is black, internal\n");
exit(1);
} else {
p = lprev(s);
if (!ishead(p)) setrext(p, s->flink);
p = rprev(s);
if (!ishead(p)) setlext(p, s->blink);
setblack(s);
return;
}
if (ir) return;
/* Recolor */
n = s;
p = n->parent;
s = sibling(n);
while(isblack(p) && isblack(s) && isint(s) &&
isblack(s->flink) && isblack(s->blink)) {
setred(s);
n = p;
if (isroot(n)) return;
p = n->parent;
s = sibling(n);
}
if (isblack(p) && isred(s)) { /* Rotation 2.3b */
single_rotate(p, isright(n));
setred(p);
setblack(s);
s = sibling(n);
}
{ JRB x, z; char il;
if (isext(s)) {
fprintf(stderr, "DELETION ERROR: sibling not internal\n");
exit(1);
}
il = isleft(n);
x = il ? s->flink : s->blink ;
z = sibling(x);
if (isred(z)) { /* Rotation 2.3f */
single_rotate(p, !il);
setblack(z);
if (isred(p)) setred(s); else setblack(s);
setblack(p);
} else if (isblack(x)) { /* Recoloring only (2.3c) */
if (isred(s) || isblack(p)) {
fprintf(stderr, "DELETION ERROR: 2.3c not quite right\n");
exit(1);
}
setblack(p);
setred(s);
return;
} else if (isred(p)) { /* 2.3d */
single_rotate(s, il);
single_rotate(p, !il);
setblack(x);
setred(s);
return;
} else { /* 2.3e */
single_rotate(s, il);
single_rotate(p, !il);
setblack(x);
return;
}
}
}