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 Ruby (judge verdict: Wrong Answer)

class Tree
    attr_accessor :key, :left, :right
    def initialize(k, l, r)
        @key   = k
        @left  = l
        @right = r
    end
end

def insert(x, tree)
    if tree == nil
        Tree.new(x, nil, nil)
    elsif x < tree.key
        Tree.new(tree.key, insert(x, tree.left), tree.right)
    elsif x > tree.key
        Tree.new(tree.key, tree.left, insert(x, tree.right))
    else
        tree
    end
end

def find(x, tree)
    if tree == nil then
        false
    elsif x < tree.key
        find(x, tree.left)
    elsif x > tree.key
        find(x, tree.right)
    else
        true
    end
end

def delete(x, tree)
    ps = []
    xs = []
    #-- 削除対象のノードにあたるまで下る。(下りながら方向と残りを保存。)
    while x != tree.key
        if x < tree.key
            tree, ps, xs = goleft(tree, ps, xs)
        else
            tree, ps, xs = goright(tree, ps, xs)
        end
    end

    #-- 削除対象のノードの子ノードが無いor 左のみor右のみor両方
    #-- で場合分け
    if tree.left == nil
        if tree.right == nil
            tree = nil #-- 両方なければ消すだけ
        else
            tree = tree.right #-- 右のみならそれを使う
        end
    else
        if tree.right == nil
            tree = tree.left #-- 左のみならそれを使う
        else
            #-- 左右ともある場合は、削除対象のノードを根とする木を
            #-- minswapに渡して、渡した木の最小値を根として再構成した部分木を受け取る。
            tree = minswap(tree)
        end
    end

    #-- 木を再構成
    while ps != []
        tree, ps, xs = goup(tree, ps, xs)
    end
    tree
end

def minswap(tree)
    #-- treeの中のうち、根を除く最小値を探して、
    #-- それを根として再構成して返す。
    directions = []
    breadcrambs = []

    if tree.left != nil
        while tree.left != nil
            tree, directions, breadcrambs = goleft(tree, directions, breadcrambs)
        end
        swapkey = tree.key

        #-- 最小値の節の右部分木とすりかえて木を再構成する。
        tree = tree.right
        while breadcrambs != []
            tree, directions, breadcrambs = goup(tree, directions, breadcrambs)
        end

        #-- 再構成した木の根（削除したい値）を右部分木の最小値に変更して返す。
        tree.key = swapkey
    elsif tree.right != nil
        tree = minswap(tree.right)
    end
    tree
end

def goleft(tree, directions, breadcrambs)
    rt = tree.left
    tree.left = nil
    directions << 'L'
    breadcrambs << tree
    [rt, directions, breadcrambs]
end

def goright(tree, directions, breadcrambs)
    rt = tree.right
    tree.right = nil
    directions << 'R'
    breadcrambs << tree
    [rt, directions, breadcrambs]
end

def goup(tree, directions, breadcrambs)
    d = directions[-1]
    xtree = breadcrambs[-1]
    if d == 'L' then xtree.left = tree
    else xtree.right = tree end
    [xtree, directions[0..-2], breadcrambs[0..-2]]
end

def preorder(tree)
    if tree != nil
        print " #{tree.key}"
        preorder(tree.left)
        preorder(tree.right)
    end
end

def inorder(tree)
    if tree != nil
        inorder(tree.left)
        print " #{tree.key}"
        inorder(tree.right)
    end
end

def postorder(tree)
    if tree != nil
        postorder(tree.left)
        postorder(tree.right)
        print " #{tree.key}"
    end
end

#-- main
#------------------------------------------
tree = nil
paths = []
breads = []

x = gets.chomp.to_i
x.times {
    cmd, n = gets.chomp.split
    case cmd
    when "insert"
        tree = insert(n.to_i, tree)
    when "find"
        if find(n.to_i, tree)
            puts "yes"
        else
            puts "no"
        end
    when "delete"
        tree = delete(n.to_i, tree)
    when "print"
        inorder(tree); puts
        preorder(tree); puts
    end
}