fork download

copy

#include <stdio.h>
#include <stdlib.h>
 
typedef struct node
{
	struct node *left;
	char color;
	struct node *right;
	struct node *p;
	int data;
}node;
node *root = NULL;
 
struct node *newNode(int key)
{
    struct node *temp =  (struct node *)malloc(sizeof(struct node));
    temp->data = key;
    temp->left = temp->right = NULL;
    temp->color='R';
    return temp;
}
 
 void left_rotate( node *x ) {
    node *y;
    y = x->right;
    x->right = y->left;
    if ( y->left != NULL )
        y->left->p = x;
    y->p = x->p;
 
    if ( x->p == NULL ) root = y;
    else
        if ( x == (x->p)->left )
             x->p->left = y;
        else
 
            x->p->right = y;
    y->left = x;
    x->p = y;
    return;
    }
 
void right_rotate( node *x ) {
    node *y;
    y = x->left;
    x->left = y->right;
    if ( y->right != NULL )
        y->right->p = x;
		y->p = x->p;
    if ( x->p == NULL ) T->root = y;
    else
        if ( x == (x->p)->right )
  			x->p->right = y;
        else
          	  x->p->left = y;
          	 y->right = x;
    		x->p = y;
    		return;
    }
 
 
 
void rbinsert (int val) {
	node *z=newNode(val);
    node *x = root;
    node *y;
 while (x ≠ NULL)
 	{
 		y = x;
 		if (z->data < x->data)
 			x = x->left;
 		else x = x->right;
 	}
 
 z->p = y;
 if (y == NULL)
 	root = z;
 else if (z->data < y->data)
 	y->left = z;
 else y->right = z;
 z->left = NULL;
 z->right = NULL;
 z->color = 'R';
 rb_fix(z) ;
 return;
}
 
 
 void rb_fix(int val)
 {
 	node *z=newNode(val);
 	while (z->p->color = 'R')
 	{
      if (z->p == z->p->p->left)
      	{
      		y=z->p->p->right;
      		if(y->color=='R')
      		{
      			z->p->color='B';
      			y->color='B';
      			z->p->p->color='R';
      			z=z->p->p;
      		}
      		else
      		{ 
      			if (z==z->p->right)
      			{
      				z=z->p;
      				left_rotate(z);
      			}
      		z->p->color='B';
      		z->p->p->color='R';
      		right_rotate(z->p->p);
      		}	
      		else
      		{
      				y=z->p->p->left;
      		if(y->color=='R')
      		{
      			z->p->color='B';
      			y->color='B';
      			z->p->p->color='R';
      			z=z->p->p;
      		}
      		else
      		{ 
      			if (z==z->p->left)
      			{
      				z=z->p;
      				right_rotate(z);
      			}
      		z->p->color='B';
      		z->p->p->color='R';
      		left_rotate(z->p->p);
      		}	
      		}
 	}
 	root->color='B';
 }
 
void prefixtour(node *p)
{
	if (p==NULL)
		{
		printf("empty tree");
		return ;
	}
 
	else
		visit(p);
	return ;
}
 
void visit( node *x)
{
	if(x!=NULL)
	{
 
		visit(x->left);
		if(x->p==NULL)
		printf( "%d %c NIL\n",x->data,x->color);
		else
		printf( "%d %c %d\n",x->data,x->color,x->p->data);
		visit(x->right);
	}
	return;
}
 
int main()
{
	int n;
	scanf("%d",&n);
	int i,key;
	for(i=0;i<n;i++)
	{
    	scanf("%d",&key);
    	rb_insert(key);
	}
	prefixtour(root);
return 0;
 
}
 
 

prog.c: In function ‘right_rotate’:
prog.c:50:25: error: ‘T’ undeclared (first use in this function)
     if ( x->p == NULL ) T->root = y;
                         ^
prog.c:50:25: note: each undeclared identifier is reported only once for each function it appears in
prog.c: In function ‘rbinsert’:
prog.c:67:11: error: stray ‘\342’ in program
  while (x ≠ NULL)
           ^
prog.c:67:12: error: stray ‘\211’ in program
  while (x ≠ NULL)
            ^
prog.c:67:13: error: stray ‘\240’ in program
  while (x ≠ NULL)
             ^
prog.c:67:9: error: called object ‘x’ is not a function or function pointer
  while (x ≠ NULL)
         ^
prog.c:65:11: note: declared here
     node *x = root;
           ^
prog.c:84:2: warning: implicit declaration of function ‘rb_fix’ [-Wimplicit-function-declaration]
  rb_fix(z) ;
  ^~~~~~
prog.c: At top level:
prog.c:89:7: warning: conflicting types for ‘rb_fix’
  void rb_fix(int val)
       ^~~~~~
prog.c:84:2: note: previous implicit declaration of ‘rb_fix’ was here
  rb_fix(z) ;
  ^~~~~~
prog.c: In function ‘rb_fix’:
prog.c:92:3: warning: suggest parentheses around assignment used as truth value [-Wparentheses]
   while (z->p->color = 'R')
   ^~~~~
prog.c:96:9: error: ‘y’ undeclared (first use in this function)
         y=z->p->p->right;
         ^
prog.c:115:9: error: expected ‘}’ before ‘else’
         else
         ^~~~
prog.c: In function ‘prefixtour’:
prog.c:150:3: warning: implicit declaration of function ‘visit’ [-Wimplicit-function-declaration]
   visit(p);
   ^~~~~
prog.c: At top level:
prog.c:154:6: warning: conflicting types for ‘visit’
 void visit( node *x)
      ^~~~~
prog.c:150:3: note: previous implicit declaration of ‘visit’ was here
   visit(p);
   ^~~~~
prog.c: In function ‘main’:
prog.c:177:6: warning: implicit declaration of function ‘rb_insert’ [-Wimplicit-function-declaration]
      rb_insert(key);
      ^~~~~~~~~

Standard output is empty