Problem:
Binary Search Tree II

Write a program which performs the following operations to a binary search tree $T$ by adding the find operation to A: Binary Search Tree I.

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

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

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

Input

In the first line, the number of operations $m$ is given. In the following $m$ lines, operations represented by insert $k$, find $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

10
insert 30
insert 88
insert 12
insert 1
insert 20
find 12
insert 17
insert 25
find 16
print

Sample Output 1

yes
no
1 12 17 20 25 30 88
30 12 1 20 17 25 88

Reference

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

Solution in Rust (judge verdict: Accepted)

use std::fmt::Write;
use Node::{Nil, Cons};
use std::fmt::Display;
use std::cell::RefCell;
use std::rc::Rc;

fn main() {
    let mut bst: BST<i32>  = BST::new();
    let n: i32 = read();
    for _ in 0..n {
        let vec: Vec<String> = read_as_vec();
        let cmd: &str = &vec[0];
        if cmd == "insert" {
            let key: i32 = vec[1].parse().ok().unwrap();
            bst.insert(key);
        } else if cmd == "find" {
            let key: i32 = vec[1].parse().ok().unwrap();
            if bst.find(key) {
                println!("yes");
            } else {
                println!("no");
            }
        } else if cmd == "delete" {
            let key: i32 = vec[1].parse().ok().unwrap();
            bst.delete(key);
        } else if cmd == "print" {
            println!(" {}", bst.inorder());
            println!(" {}", bst.preorder());
        }

    }
}

#[derive(Ord, PartialOrd, Eq, PartialEq, Debug)]
enum Node<T: Ord + PartialOrd + Eq + PartialEq  + Display> {
    Nil,
    Cons(
        Rc<RefCell<T>>,
        Rc<RefCell<Node<T>>>,
        Rc<RefCell<Node<T>>>,
        ),
}

struct BST<T: Ord + PartialOrd + Eq + PartialEq + Display> {
    root: Rc<RefCell<Node<T>>>
}

impl<T: Ord + PartialOrd + Eq + PartialEq + Display> BST<T> {
    fn new() -> BST<T> {
        BST { root: Rc::new(RefCell::new(Nil)) }
    }

    fn find(&mut self, target: T) -> bool {
        Node::find(Rc::clone(& self.root), target).is_some()
    }

    fn insert(&mut self, value: T) {
        Node::insert(Rc::clone(& self.root), value);
    }

    fn delete(&mut self, target: T) {
        if let Some((ptr, node)) = Node::find_for_delete(&mut self.root, Rc::clone(& self.root), target) {
            Node::delete(ptr, node);
        }
    }

    fn preorder(&self) -> String {
        let mut buf: String = String::new();
        Node::preorder(Rc::clone(& self.root), &mut buf);
        buf.pop();
        buf
    }

    fn inorder(&self) -> String {
        let mut buf: String = String::new();
        Node::inorder(Rc::clone(& self.root), &mut buf);
        buf.pop();
        buf
    }
}

impl<T: Ord + PartialOrd + Eq + PartialEq + Display> Node<T> {
    fn insert(node: Rc<RefCell<Node<T>>>, value: T) {
        match *node.borrow_mut() {
            Cons(ref v, ref l, ref r) => {
                if value < *v.borrow() {
                    Self::insert(Rc::clone(l), value);
                } else if value > *v.borrow() {
                    Self::insert(Rc::clone(r), value);
                }
            }, ref mut nil => { *nil = Cons(
                    Rc::new(RefCell::new(value)),
                    Rc::new(RefCell::new(Nil)),
                    Rc::new(RefCell::new(Nil)),
                    );
            }
        }
    }

    fn find(node: Rc<RefCell<Node<T>>>, target: T) -> Option<Rc<RefCell<Node<T>>>> {
        if let Cons(ref v, ref l, ref r) = *node.borrow() {
            if target < *v.borrow() {
                Self::find(Rc::clone(l), target)
            } else if target > *v.borrow() {
                Self::find(Rc::clone(r), target)
            } else {
                Some(Rc::clone(& node))
            }
        } else {
            None
        }
    }

    fn find_for_delete(ptr: *mut Rc<RefCell<Node<T>>>, node: Rc<RefCell<Node<T>>>, target: T) ->
        Option<(*mut Rc<RefCell<Node<T>>>, Rc<RefCell<Node<T>>>)> {
        if let Cons(ref v, ref mut l, ref mut r) = *node.borrow_mut() {
            if target < *v.borrow() {
                Self::find_for_delete(l, Rc::clone(l), target)
            } else if target > *v.borrow() {
                Self::find_for_delete(r, Rc::clone(r), target)
            } else {
                Some((ptr, Rc::clone(& node)))
            }
        } else {
            None
        }
    }

    fn find_next_node(ptr: *mut Rc<RefCell<Node<T>>>, node: Rc<RefCell<Node<T>>>) ->
        Option<(*mut Rc<RefCell<Node<T>>>, Rc<RefCell<Node<T>>>)> {
        if let Cons(_, ref mut l, _) = *node.borrow_mut() {
            if *l.borrow() == Nil {
                Some((ptr, Rc::clone(& node)))
            } else {
                Self::find_next_node(l, Rc::clone(l))
            }
        } else {
            None
        }
    }

    fn delete(ptr: *mut Rc<RefCell<Node<T>>>, node: Rc<RefCell<Node<T>>>) {
        let replace: Option<Rc<RefCell<Node<T>>>> = match *node.borrow() {
            Cons(_, ref l, ref r) => {
                if *l.borrow() == Nil && *r.borrow() == Nil {
                    Some(Rc::new(RefCell::new(Nil)))
                } else if *l.borrow() == Nil {
                    Some(Rc::clone(r))
                } else if *r.borrow() == Nil {
                    Some(Rc::clone(l))
                } else {
                    None
                }
            },
            Nil => None, // unreachable
        };
        if let Some(replace) = replace {
            unsafe {
                *ptr = replace;
            }
        } else {
            if let Cons(ref mut v, _, ref mut r) = *node.borrow_mut() {
                let (next_ptr, next_node) = Self::find_next_node(r, Rc::clone(r)).unwrap();
                if let Cons(ref cv, ..) = *next_node.borrow() {
                    *v = Rc::clone(cv);
                }
                Node::delete(next_ptr, next_node);
            }
        }
    }

    fn preorder(node: Rc<RefCell<Node<T>>>, buf: &mut String) {
        if let Cons(ref v, ref l, ref r) = *node.borrow() {
            write!(buf, "{} ", *v.borrow()).unwrap();
            Self::preorder(Rc::clone(l), buf);
            Self::preorder(Rc::clone(r), buf);
        }
    }

    fn inorder(node: Rc<RefCell<Node<T>>>, buf: &mut String) {
        if let Cons(ref v, ref l, ref r) = *node.borrow() {
            Self::inorder(Rc::clone(l), buf);
            write!(buf, "{} ", *v.borrow()).unwrap();
            Self::inorder(Rc::clone(r), buf);
        }
    }

}

fn read<T: std::str::FromStr>() -> T {
    let mut input = String::new();
    std::io::stdin().read_line(&mut input).unwrap();
    input.trim().parse::<T>().ok().unwrap()
}

fn read_as_vec<T: std::str::FromStr>() -> Vec<T> {
    read::<String>()
        .split_whitespace()
        .map(|e| e.parse::<T>().ok().unwrap())
        .collect()
}