Recursively search binary search tree by name

public object find(string country)
   {
       return find(country, root);
   }


   private object find(string item, Node<T> tree)
   {
       int compare;
       while (tree != null)
       {
           string[] outcome = tree.Data.ToString().Split(',');
           compare = outcome[0].CompareTo(item);
           if (compare == 0)
           {
               return tree.Data;


           }
           else if (compare > 0)
           {
               tree = tree.Left;
           }
           else if (compare < 0)
           {
               tree = tree.Right;
           }
       }

       return null;

public object findcountryInformation(string countryName)


    {
        object result = myTree.find(countryName);

        return result;
    }


    private void button1_Click(object sender, EventArgs e)
    {


        string text = listBox1.GetItemText(listBox1.SelectedItem);



        object result = findcountryInformation(text);



        Console.WriteLine(result);

}}

class BSTree<T> : BinTree<T> where T : IComparable
   {
       public BSTree()
       {
           root = null;
       }

       public void InsertItem(T item)
       {
           insertItem(item, ref root);
       }

       private void insertItem(T item, ref Node<T> tree)
       {
           if (tree == null)
               tree = new Node<T>(item);

           else if (item.CompareTo(tree.Data) < 0)
               insertItem(item, ref tree.Left);

           else if (item.CompareTo(tree.Data) > 0)
               insertItem(item, ref tree.Right);

       }

       private int max(int x, int y)
       {
           if (y > x)
               return y;

           return x;
       }

       public int Height()
       {
           return height(root);
       }

       private int height(Node<T> tree)
       //Return the max level of the tree
       {
           if (tree == null)
               return 0;
           return 1 + max(height(tree.Left), height(tree.Right));
       }

       public Boolean Contains(T item)
       {
           Node<T> node = root;
           return contains(root, item);
       }

       private Boolean contains(Node<T> node, T item)
       {
           if (node == null)
               return false;

           //if (node.Data == item)
           if (item.CompareTo(node.Data) < 0)
               return contains(node.Left, item);
           if (item.CompareTo(node.Data) > 0)
               return contains(node.Right, item);
           return true;
       }

    class Node<T> where T : IComparable
        
    {
        
        private T data;
        public Node<T> Left, Right;


        public Node(T item)
        {
            data = item;
            Left = null;
            Right = null;
        }
        public T Data
        {
            set { data = value; }
            get { return data; }
        }


    }
}