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>          // printf(), scanf()
#define MAX_N 500000
 
typedef struct node_tbl
{
    int key;
    int parent;
    int left;
    int right;
} node;
 
const int nil = -1;
node t[MAX_N + 1];
int root;

int ix;
 
int
tree_minimum(int u)
{
    while (t[u].left != nil)
        u = t[u].left;
 
    return u;
}
 
int
find(int u, int k)
{
    while (u != nil && k != t[u].key)
    {
        if (k < t[u].key)
            u = t[u].left;
        else
            u = t[u].right;
    }
 
    return u;
}
 
int
tree_successor(int u)
{
    if (t[u].right != nil)
        return tree_minimum(t[u].right);
 
    int y = t[u].parent;
    while (y != nil && u == t[y].right)
    {
        u = y;
        y = t[y].parent;
    }
 
    return y;
}
 
void
delete(int z)
{
    int y; /* ????????????????±? */
    int x; /* y?????? */
 
    /* ??????????????????????±??????? */
    if (t[z].left == nil || t[z].right == nil)
        y = z;
    else
        y = tree_successor(z);
 
    /* y??????x????±??????? */
    if (t[y].left != nil)
        x = t[y].left;
    else
        x = t[y].right;
 
    if (x != nil)
        t[x].parent = t[y].parent;
 
    if (t[y].parent == nil)
        root = x;
    else
    {
        if (y == t[t[y].parent].left)
            t[t[y].parent].left = x;
        else
            t[t[y].parent].right = x;
    }
 
    if (y != z)
        t[z].key = t[y].key;

}
 
void
insert(int k)
{
    int z;
 
    int y = nil;
    int x = root;

        z = ix++;

 
    t[z].key = k;
    t[z].left = nil;
    t[z].right = nil;
 
    while (x != nil)
    {
        y = x;
        if (t[z].key < t[x].key)
            x = t[x].left;
        else
            x = t[x].right;
    }
 
    t[z].parent = y;
    if (y == nil)
        root = z;
    else
    {
        if (t[z].key < t[y].key)
            t[y].left = z;
        else
            t[y].right = z;
    }
}
 
void
inorder(int u)
{
    if (u == nil)
        return;
 
    inorder(t[u].left);
    printf(" %d", t[u].key);
    inorder(t[u].right);
}
 
void
preorder(int u)
{
    if (u == nil)
        return;
 
    printf(" %d", t[u].key);
    preorder(t[u].left);
    preorder(t[u].right);
}
 
int
main(int argc, char** argv)
{
    char command[8];
    int n;
    int x;
    int i;
 
    root = nil;

    ix = 0;
    scanf("%d", &n);
    for (i = 0; i < n; ++i)
    {
        scanf("%s", command);
        switch (command[0])
        {
        case 'd':
            scanf("%d", &x);
            delete(find(root, x));
            break;
 
        case 'f':
            scanf("%d", &x);
            printf("%s\n", find(root, x) != nil ? "yes" : "no");
            break;
 
        case 'i':
            scanf("%d", &x);
            insert(x);
            break;
 
        case 'p':
        default:
            inorder(root);
            printf("\n");
 
            preorder(root);
            printf("\n");
            break;
        }
    }
 
    return 0;
}