This is the same code as the above one. I thought you would need it for testing and compiling. Sorry and thank you.

Tree.cpp without the line numbers now.

Code:
#include <iostream>
#include "Tree.h"
using namespace std;
BinarySearchTree::~BinarySearchTree()
{
    DeleteWholeTree(root_);
}

void BinarySearchTree::DeleteWholeTree(TreeNode* tnPtr)
{
    // Deleting the whole tree
    DeleteWholeTree(tnPtr->left_);
    DeleteWholeTree(tnPtr->right_);
    delete tnPtr;
    tnPtr=NULL;
}

TreeNode* BinarySearchTree::InsertTree(TreeNode* tnPtr,
                                                         const TreeItemType& item)

throw (TreeException)
{
     // Inserting an item
     if(tnPtr == NULL){
     tnPtr = new TreeNode(item);
     return tnPtr;
  }
     if(item == tnPtr->item_)
     return tnPtr;
     if(item <= tnPtr->item_){
     tnPtr->left_ =  InsertTree(tnPtr->left_, item);
     return tnPtr;
  }
     else if(item > tnPtr->item){
     tnPtr->right_ = InsertTree(tnPtr->right_, item);
     return tnPtr;
  }

}
   
TreeNode* BinarySearchTree::DeleteTree(TreeNode* tnPtr,
                                                            const TreeItemType& item)
{
     if(isEmpty())
     throw (TreeException)("TreeException: Empty tree");
     else
            {
                // Deleting an item
               if(tnPtr->left_ == NULL && tnPtr->right_ == NULL)
               {
                  if(item == tnPtr->item_)
                  return NULL;
               }
              else if(tnPtr->left_ == NULL && tnPtr->right_ != NULL)
               {
                   if(item == tnPtr->item_)
                   return tnPtr->right_;
                   else
                         tnPtr->right_ = delete(item_,tnPtr->right_);
                         return tnPtr;
               }
                   else if(tnPtr->right_ == NULL && tnPtr->left_ != NULL)
                           {
                               if(item == tnPtr->item_)
                               return tnPtr->left_;
                               else
                                     tnPtr->left_ == delete(item_,tnPtr->left_);
                                     return tnPtr;
                           }
                  else if(tnPtr->left_ != NULL && tnPtr->right_ != NULL)
                           {
                               if(item == tnPtr->item_)
                               tnPtr->item_ = FindMin(tnPtr->right_);
                               tnPtr->right_ = delete(tnPtr->item_, tnPtr->right_);
     
                               else if(item < tnPtr->item_)
                               tnPtr->left_ = delete(item, tnPtr->left_);
      
                               else
                                     tnPtr->right_ = delete(item, tnPtr->right_);
                                     return tnPtr;
                           }
              }
     }
int BinarySearchTree::SearchTree(const TreeNode* tnPtr,
                                                  const TreeItemType item, int nLinks)
{
    // Searching an item
   // and also returning the number of links from root

   if(tnPtr == NULL)
      return NULL;
   if(item == tnPtr->item_)
      return nlinks;
   else if (item < tnPtr->item_)
         search(item, tnPtr->left_, nlinks += 1);
         return nlinks;
   else
         search(item, tnPtr->right_, nlinks += 1);
         return nlinks;
   if(item != tnPtr->item_)
        nlinks = -1;
        return nlinks;
  
}
 
void BinarySearchTree::Traversal(const TreeNode* tnPtr,int mode)
{
    // Traversal (inorder)
    if(tnPtr != NULL)
         {
               Traversal(tnPtr->left_);
                cout << tnPtr->item_ << endl;
               Traversal(tnPtr->right_);
          }
}
     
TreeItemType BinarySearchTree::FindMin(const TreeNode* tnPtr)
{
    // Finding the minimum item
    while (tnPtr->left_ != NULL)
    tnPtr = tnPtr->left_;
    return tnPtr->item_;
}
 
TreeItemType BinarySearchTree::FindMinimum()
{
    // Calling FindMin
    FindMin(root_);
}
 
bool BinarySearchTree::Insert(TreeItemType item)
{
    // Calling InsertTree
    InsertTree(root_, item);
}
 
bool BinarySearchTree::Delete(TreeItemType item)
{
    // Calling DeteteTree
    DeleteTree(root_);
}
 
void BinarySearchTree::DeleteAll()
{
    // Calling DeleteWholeTree
    DeleteWholeTree(root_);
}
 
int BinarySearchTree::Search(const TreeItemType item)
{
    // Calling SearchTree
    SearchTree(root_);
}
 
void BinarySearchTree::InorderTraversal()
{
    //  Calling Traversal
    Traversal(root_);
}
Thank You