import java.util.Stack;

public class Tree<T extends Comparable<T>> {
	public Tree(T v) {
		value = v;
		left = null;
		right = null;
	}

	public void insert(T v) {
		if (value.compareTo(v) == 0)
			return;
		if (value.compareTo(v) > 0)
			if (left == null)
				left = new Tree<T>(v);
			else
				left.insert(v);
		else if (value.compareTo(v) < 0)
			if (right == null)
				right = new Tree<T>(v);
			else
				right.insert(v);
	}

	protected T value;
	protected Tree<T> left;
	protected Tree<T> right;
}

class IntElem implements Comparable<IntElem> {
	public IntElem(int value) {
		this.value = value;
	}

	public int value() {
		return value;
	}

	public int compareTo(IntElem o) {
		return value - o.value();
	}

	private int value;
}

// StringElem class is not needed 
class StringElem implements Comparable<StringElem> {
	public StringElem(String value) {
		this.value = value;
	}

	public String value() {
		return value;
	}

	public int compareTo(StringElem s) {
		return value.compareTo(s.value());
	}
	private String value;
}

class Iter<T extends Comparable<T>> {

	public Iter(Tree<T> root) {
		stack.push(root);
		dfs(root);
	}

	public boolean done() { 
		return stack.isEmpty();
	}

	public T next() {
        Tree<T> node = stack.pop();
		if (node.right != null) {
	        stack.push(node.right);
		    dfs(node.right);
		}
        return node.value;  
      }

	private void dfs(Tree<T> node) {
		if (node.left != null) {
			stack.push(node.left);
			dfs(node.left);
		}
	}

	Stack<Tree<T>> stack = new Stack<Tree<T>>();
}


class GenericTreeDriver {

    static <T extends Comparable<T>> boolean lazyequal(Tree<T> tree1, Tree<T> tree2) {
		Iter<T> iter1 = new Iter<T>(tree1);
		Iter<T> iter2 = new Iter<T>(tree2);
		while (!iter1.done() && !iter2.done()) {
			T i1 = iter1.next();
			T i2 = iter2.next();
			if (i1.compareTo(i2) != 0) return false;
		}
		return iter1.done() && iter2.done();
	}
	
	public static void main(String[] args) {
		Tree<IntElem> tree1 = new Tree<IntElem>(new IntElem(50));
		tree1.insert(new IntElem(10));
		tree1.insert(new IntElem(500));
		tree1.insert(new IntElem(100));
		tree1.insert(new IntElem(90));
		tree1.insert(new IntElem(200));
		tree1.insert(new IntElem(300));
		
		Tree<IntElem> tree2 = new Tree<IntElem>(new IntElem(100));
		tree2.insert(new IntElem(90));
		tree2.insert(new IntElem(200));
		tree2.insert(new IntElem(50));
		tree2.insert(new IntElem(300));
		tree2.insert(new IntElem(500));
		tree2.insert(new IntElem(10));		
		boolean b = lazyequal(tree1,tree2);
	}
}