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: Accepted)

import java.util.Scanner;
import java.lang.Integer;
import java.lang.StringBuilder;
import java.lang.Math;

class Node {
  Node left;
  Node right;
  int value;

  public Node (int x) {
    this.value = x;
    this.left = null;
    this.right = null;
  }

  public void insert(int x) {
    if (x < this.value) {
      if (left == null) {
        left = new Node(x);
        return;
      } else {
        left.insert(x);
        return;
      }
    } else {
      if (right == null) {
        right = new Node(x);
        return;
      } else {
        right.insert(x);
        return;
      }
    }
  }

  public boolean find(int key) {
    if (this.value == key) {
      return true;
    } else if (key < this.value) {
      if(left == null) {
        return false;
      } else {
        return left.find(key);
      }
    } else if (key > this.value) {
      if (right == null) {
        return false;
      } else {
        return right.find(key);
      }
    }
    // never come here
    return false;
  }

  public void printInOrder(){
    if (left != null) {
      left.printInOrder();
    }

    process();

    if (right != null) {
      right.printInOrder();
    }
  }

  public void printPreOrder(){
    process();

    if (left != null) {
      left.printPreOrder();
    }

    if (right != null) {
      right.printPreOrder();
    }
  }


  private void process() {
    System.out.print(" ");
    System.out.print(value);
  }
}

class BinaryTree {
  Node root;

  public BinaryTree() {}

  public void insert(int x) {
    if (root == null) {
      root = new Node(x);
      return;
    }

    if (x < root.value) {
      if (root.left == null) {
        root.left = new Node(x);
        return;
      } else {
        root.left.insert(x);
        return;
      }
    } else {
      if (root.right == null) {
        root.right = new Node(x);
        return;
      } else {
        root.right.insert(x);
        return;
      }
    }
  }

  public void find(int key) {
    if (root != null) {
      boolean found = root.find(key);
      if (found) {
        System.out.println("yes");
        return;
      }
    }
    System.out.println("no");
  }

  public void printInOrder() {
    if (root != null) {
      root.printInOrder();
    }
    System.out.println();
  }

  public void printPreOrder() {
    if (root != null) {
      root.printPreOrder();
    }
    System.out.println();
  }

  public void print() {
    printInOrder();
    printPreOrder();
  }
}



public class Main {
  private static int N;
  final static String INSERT = "insert";
  final static String FIND = "find";
  final static String PRINT = "print";

  public static void main(String[] args) {
    Scanner in = new Scanner(System.in);
    int N = in.nextInt();
    BinaryTree tree = new BinaryTree();

    for (int i = 0; i < N; i++) {
      String cmd = in.next();
      switch(cmd) {
        case INSERT:
          tree.insert(in.nextInt());
          break;
        case FIND:
          tree.find(in.nextInt());
          break;
        case PRINT:
          tree.print();
          break;
        default:
          System.out.println("Error");
          System.exit(1);
      }
    }
  }
}