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 JAVA (judge verdict: Time Limit Exceeded)

import java.util.Scanner;

public class Main {
    static Node[] list;
    public static void main(String[] args){
    	Scanner sc = new Scanner(System.in);
        int m= Integer.parseInt(sc.next());
        String s;
        int reg=0;
        int flag=1;
        int reg2;
        StringBuilder str;
        StringBuilder str2;
        list=new Node[m];
        for(int i=0;i<m;i++) list[i] = new Node();
        
        for(int i=0;i<m;i++){
        	s=sc.next();
        	if(s.equals("insert")){
        		list[i].number=Integer.parseInt(sc.next());
        		if(flag==1){
        			reg=i;
        			list[reg].pid=-1;
        			flag=0;
        		}else{
        			insert(list[reg],list,i);
        		}
        	}else if(s.equals("print")){
        		str=new StringBuilder();
        		str2=new StringBuilder();
        		naka(list,list[reg],str);
        		mae(list,list[reg],str2);
            }else if(s.equals("find")){
            	reg2=sc.nextInt();
            	for(int j=0;j<i;j++){
            		if(list[j].number==reg2){
            			System.out.println("yes");
            			break;
            		}else if(j==i-1){
            			System.out.println("no");
            		}
            	}
            }
        }
    }
    static void insert(Node node,Node[] list,int i){
        if(list[i].number>node.number){
            if(node.right==null){
            	node.right=list[i];
            }else{
            	insert(node.right,list,i);
            }
        }else {
        	if(node.left==null){
        		node.left=list[i];
        	}else{
        		insert(node.left,list,i);
        	}
        }
    }
    static void mae(Node[] list, Node node,StringBuilder str){
    	str.append(" "+node.number);
    	if(node.left!=null){
    		mae(list,node.left,str);
    	}
    	if(node.right!=null){
    		mae(list,node.right,str);
    	}
    	if(node.pid==-1){
    		System.out.println(str);
    	}
    }
    static void naka(Node[] list, Node node,StringBuilder str){
    	if(node.left!=null){
    		naka(list,node.left,str);
    	}
    	str.append(" "+node.number);
    	if(node.right!=null){
    		naka(list,node.right,str);
    	}
    	if(node.pid==-1){
    		System.out.println(str);
    	}
    }
}

class Node{
	int number;
	Node left;
	Node right;
	int pid;
	Node(){
		pid=0;
		number=-1;
		left=null;
		right=null;
	}
}