Language: C


#include<stdio.h>
#include<stdlib.h>

struct node{
  struct node *right;
  struct node *left;
  struct node *parent;
  int key;
};
typedef struct node * Node;
#define NIL NULL

Node root;

Node tree_left_max(Node x){
	Node left_biggest, parent_node;

	left_biggest = x->left;
	parent_node=x;
	while(left_biggest->right!=NULL){
		parent_node = left_biggest;
	    left_biggest = left_biggest->right;
	}
	return left_biggest;
}

Node tree_search(Node u, int k){

	if(u->key > k){
		if(u->left==NIL){  
			return NIL;
		}
		return treeSearch(u->left, k);
	}
	
	if(u->key < k){
		if(u->right == NULL){
			return NULL;      
		}
		return treeSearch(u->right, k);
	}

	return u;
}

Node tree_successor(Node x){

	return root;
}

void tree_delete(Node z){
  Node left_max;
  int direction; //if z is left child: -1, right child: 1, other: 0
  if(z->parent->right == z){
	  direction = 1;
  } else if(z->parent->left == z){
	  direction = -1;
  } else {
	  direction = 0;
  }
  if(z != NIL){
	  if(z->left == NIL || z->right == NIL){
            
		  if(z->left == NIL){
                
			  if(direction == -1){
                     z->parent->left = z->right;
			  }
              if(direction == 1){
                     z->parent->right = z->right;
              }
              if(direction == 0){
                     root = z->right;
              }
		  } else {
            
              if(direction == -1){
                  z->parent->left = z->left;
              }
              if(direction == 1){
                  z->parent->right = z->left;
              }
              if(direction == 0){
                  root = z->left;
              }
           }
             free(z);
         } else {
             
        	left_max = tree_left_max(z);

             z->key = left_max->key;
             if(direction==-1){
                 z->parent->left = left_max->left;
             } else {
                 z->parent->right = left_max->left;
             }
          free(left_max);
       }
    }


}

Node new_node(Node n, int k){
	Node z;

	z = malloc(sizeof(struct node));
	z->key = k;
	z->left = NIL;
	z->right = NIL;
	z->parent = n;
	return z;
}

void insert(int k){
  Node y = NIL;
  Node x = root;

  if(x->key > k){
	  if(x->left != NIL){
		  insert_tree(x->left, k);
	  } else {
		
		  x->left = new_node(x, k);
	  }
  } else {
 
	  if(x->right != NIL){
		  insert_tree(x->right, k);
	  } else {
		  
		  x->right=new_node(x, k);
	  }
   }
  return;
}

void inorder(Node u){
	if(u != NIL){
		inorder(u->left);
		printf("%d", u->key);
		inorder(u->right);
	}
}

void preorder(Node u){
	printf(u->key);
	if (u->left != NIL){
		preorder(u->left);
	}

	if (u->right != NIL){
	    preorder(u->right);
	}
}


int main(){
  int n, i, x;
  char com[20];
  scanf("%d", &n);

  for ( i = 0; i < n; i++ ){
    scanf("%s", com);
    if ( com[0] == 'f' ){
      scanf("%d", &x);
      Node t = treeSearch(root, x);
      if ( t != NIL ) printf("yes\n");
      else printf("no\n");
    } else if ( com[0] == 'i' ){
      scanf("%d", &x);
      insert(x);
    } else if ( com[0] == 'p' ){
      inorder(root);
      printf("\n");
      preorder(root);
      printf("\n");
    } else if ( com[0] == 'd' ){
      scanf("%d", &x);
      treeDelete(treeSearch(root, x));
    }
  }

  return 0;
}

Compiler output:
main.c: In function 'tree_search':
main.c:34:24: error: implicit declaration of function 'treeSearch'; did you mean 'tree_search'? [-Wimplicit-function-declaration]
   34 |                 return treeSearch(u->left, k);
      |                        ^~~~~~~~~~
      |                        tree_search
main.c:34:24: error: returning 'int' from a function with return type 'Node' {aka 'struct node *'} makes pointer from integer without a cast [-Wint-conversion]
   34 |                 return treeSearch(u->left, k);
      |                        ^~~~~~~~~~~~~~~~~~~~~~
main.c:41:24: error: returning 'int' from a function with return type 'Node' {aka 'struct node *'} makes pointer from integer without a cast [-Wint-conversion]
   41 |                 return treeSearch(u->right, k);
      |                        ^~~~~~~~~~~~~~~~~~~~~~~
main.c: In function 'insert':
main.c:123:19: error: implicit declaration of function 'insert_tree' [-Wimplicit-function-declaration]
  123 |                   insert_tree(x->left, k);
      |                   ^~~~~~~~~~~
main.c: In function 'preorder':
main.c:149:17: error: passing argument 1 of 'printf' makes pointer from integer without a cast [-Wint-conversion]
  149 |         printf(u->key);
      |                ~^~~~~
      |                 |
      |                 int
In file included from main.c:2:
/usr/include/stdio.h:363:43: note: expected 'const char * restrict' but argument is of type 'int'
  363 | extern int printf (const char *__restrict __format, ...);
      |                    ~~~~~~~~~~~~~~~~~~~~~~~^~~~~~~~
main.c: In function 'main':
main.c:169:16: error: initialization of 'Node' {aka 'struct node *'} from 'int' makes pointer from integer without a cast [-Wint-conversion]
  169 |       Node t = treeSearch(root, x);
      |                ^~~~~~~~~~
main.c:182:7: error: implicit declaration of function 'treeDelete'; did you mean 'tree_delete'? [-Wimplicit-function-declaration]
  182 |       treeDelete(treeSearch(root, x));
      |       ^~~~~~~~~~
      |       tree_delete