Problem:
Binary Search Tree III

Write a program which performs the following operations to a binary search tree $T$ by adding delete operation to B: Binary Search Tree II.

insert $k$: Insert a node containing $k$ as key into $T$.

find $k$: Report whether $T$ has a node containing $k$.

delete $k$: Delete a node containing $k$.

print: Print the keys of the binary search tree by inorder tree walk and preorder tree walk respectively.

The operation delete $k$ for deleting a given node $z$ containing key $k$ from $T$ can be implemented by an algorithm which considers the following cases:

If $z$ has no children, we modify its parent $z.p$ to replace $z$ with NIL as its child (delete $z$).

If $z$ has only a single child, we "splice out" $z$ by making a new link between its child and its parent.

If $z$ has two children, we splice out $z$'s successor $y$ and replace $z$'s key with $y$'s key.

Input

In the first line, the number of operations $m$ is given. In the following $m$ lines, operations represented by insert $k$, find $k$, delete $k$ or print are given.

Output

For each find $k$ operation, print "yes" if $T$ has a node containing $k$, "no" if not.

In addition, for each print operation, print a list of keys obtained by inorder tree walk and preorder tree walk in a line respectively. Put a space character before each key

Constraints

The number of operations $\leq 500,000$

The number of print operations $\leq 10$.

$-2,000,000,000 \leq key \leq 2,000,000,000$

The height of the binary tree does not exceed 100 if you employ the above pseudo code.

The keys in the binary search tree are all different.

Sample Input 1

18
insert 8
insert 2
insert 3
insert 7
insert 22
insert 1
find 1
find 2
find 3
find 4
find 5
find 6
find 7
find 8
print
delete 3
delete 7
print

Sample Output 1

yes
yes
yes
no
no
no
yes
yes
1 2 3 7 8 22
8 2 1 3 7 22
1 2 8 22
8 2 1 22

Reference

Introduction to Algorithms, Thomas H. Cormen, Charles E. Leiserson, Ronald L. Rivest, and Clifford Stein. The MIT Press.

Solution in C (judge verdict: Accepted)

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#define N 500001

typedef struct tree{
  int key;
  struct tree *parent;
  struct tree *left;
  struct tree *right;
} Tree;

Tree *createtree(int);
void insert(Tree *, int);
void find(Tree *, int);
void delete(Tree *, int);
void inorderwalk(Tree *);
void preorderwalk(Tree *);

Tree *root = NULL;

int main(){

  int m, x[N], i, j;
  char order[N][7];

  scanf("%d", &m);
  for(i = 0; i < m; i++){
    scanf(" %s", order[i]);
    if(order[i][0] != 'p') scanf("%d", &x[i]);
  }

  for(i = 0; i < m; i++){
    if(order[i][0] == 'i'){
      insert(root, x[i]);
    } 
    else if(order[i][0] == 'f'){
      find(root, x[i]);
    }
    else if(order[i][0] == 'd'){
      delete(root, x[i]);
    }
    else{
      assert(root!=NULL);
      inorderwalk(root);
      printf("\n");
      preorderwalk(root);
      printf("\n");
    }
   
  }

  return 0;
}

void insert(Tree *t, int v){
  Tree *x, *y, *z;
  z =  createtree(v);
  y = NULL;
  x = t;

  while(x != NULL){
    y = x;
    if(z->key < x->key) x = x->left;
    else x = x->right;
  }

  z->parent = y;

  if(y == NULL) root = z;
  else if(z->key < y->key) y->left = z;
  else y->right = z;  
}

void find(Tree *t, int v){
  Tree *x;
  int flag = 0;

  x = t;

 while(x != NULL){
   if(v == x->key){
     flag = 1;
     break;
   }
   if(v < x->key) x = x->left;
   else x = x->right;
  }

 if(flag == 1) printf("yes\n");
 else printf("no\n");
}

void delete(Tree *r, int k){
  int t = 0;
  Tree *x = r;
  Tree *y;

  while(x != NULL){
    if(x->key == k){
      t = 1;
      break;
    }
    if(k < x->key) x = x->left;
    else x = x->right;
  }
  if(t == 1){
    if(x->right == NULL && x->left == NULL){ 
      if(x->key > x->parent->key) x->parent->right = NULL;
      else x->parent->left = NULL;
      free(x);
    }
    else if(x->right == NULL || x->left == NULL){
      if(x->right == NULL){
	if(x->key > x->parent->key) x->parent->right = x->left;
	else x->parent->left = x->left;
	x->left->parent = x->parent;
      }
      else {
	if(x->key > x->parent->key) x->parent->right = x->right;
	else x->parent->left = x->right;
	x->right->parent = x->parent;
      }
      free(x);
    }
    else {
      y =  x->right;
      while(y->left != NULL){
	y = y->left;
      }
      if(y->right == NULL && y->left == NULL){ 
	if(y->key > y->parent->key) y->parent->right = NULL;
	else y->parent->left = NULL;
	x->key = y->key;
	free(y);
      }
      else if(y->right == NULL || y->left == NULL){
	if(y->right == NULL){
	  if(y->key > y->parent->key) y->parent->right = y->left;
	  else y->parent->left = y->left;
	  y->left->parent = y->parent;
	}
	else {
	  if(y->key > y->parent->key) y->parent->right = y->right;
	  else y->parent->left = y->right;
	  y->right->parent = y->parent;
	}
	x->key = y->key;
	free(y);
      }
    }
    
  }
}

void inorderwalk(Tree *x){
  if(x->left != NULL) inorderwalk(x->left);
  printf(" %d",x->key);
  if(x->right != NULL) inorderwalk(x->right);
}

void preorderwalk(Tree *x){
  printf(" %d",x->key);
  if(x->left != NULL) preorderwalk(x->left);
  if(x->right != NULL) preorderwalk(x->right);
}

Tree *createtree(int key){
  Tree *tree = (Tree *)malloc( sizeof(Tree) );
  tree->key = key;
  tree->parent = NULL;
  tree->left = NULL;
  tree->right = NULL;
  return tree;
}