Binary Search Tree help

[JoshuaMostafa]

Hello,

I am fairly new to C++. I am not going to lie and say this is not an assignment. Iam sorry for doing this, but I have been working on it for almost a week searching through C++ manual and tutorials. I have learnt a lot while trying to finish the project, but unfortunately could not get it to work :( . Here is my code and I put the question in the comment at the top of the file. I am getting all bunch of errors when I compile the program.

/*
Write C++ code for a class whose objects are binary search trees, 
where the data items have type integer. 
The class must contain a methods "insert", "find" (which returns a Boolean),
 "delete" as well as method "in-order print" and "pre-order print" which output
 the data in the binary search tree in in-order and post-order respectively.
Requirement:
You should design your own BST data structure.
Your program should read a text file input.txt as input. 
The input.txt contains a list of operations that your program should be able to handle, 
below are the definitions of the corresponding commands:
N insert a node
F find
D delete
I inorder output
P preorder output
For the example input file which you can find in the homework folder as:
I am expecting your output to be:
Inorder 2 3 5 7
Illegal function
Preorder 5 3 2 7
7 found
4 not found
7 not found
Inorder 2 3 5
Preorder 5 3 2
Note that your program should be able to detect any illegal command other than the five legal commands.
*/

/*input.txt
N 5
N 3
N 7
N 3
N 2
I
A 4
P
F 7
F 4
D 7
F 7
I
P
*/

#include <fstream>
#include <iostream>
#include <sstream>
#include <cstdlib>
#include <string>
#include <algorithm> 
#include <iterator> 

using namespace std;

struct node
{
	int info;
	struct node *left;
	struct node *right;
}*root;

class BST
{
	public:
        bool find(int, node **, node **);    
        bool insert(int);
        void del(int);
        void preorder(node *);
        void inorder(node *);
        BST()
        {
            root = NULL;
        }
};

int main() {
  
  ifstream myfile( "input.txt" );
  string line;  
  int num;
  string temp_str = "default";
  BST bst;
  node *temp, *par, *loc;
  
  while (!myfile.eof()) {
  	getline(myfile, line); 
  	string fun = line.substr(0, 1);
  	if (line. substr(1,2) != "") {
  		temp_str = line. substr(1,2);
  	}
  	if( temp_str != "default") {
        int num = atoi (temp_str.c_str());
    }
  		
  	if (fun != "N" && fun != "I" && fun != "P" && fun != "D" && fun != "F") {
  		fun = "Illegal function!";
  	} else {
	   
	  	if (fun == "N") {
	  		bst.insert(root, temp);
	  	}
	  	if (fun == "I") {
	  		bst.inorder(root);
	  	}
	  	if (fun == "P") {
	  		bst.preorder(root);
	  	}
	  	if (fun == "D") {
	  		bst.del(num);
	  	}
	  	if (fun == "F") {
	  		bst.find(num, par, loc);
	  	}
	}
  }

  return 0;
}

//Find an element in the tree

bool BST::find(int item, node **par, node **loc)
{
    node *ptr, *ptrsave;
    if (root == NULL)
    {
        *loc = NULL;
        *par = NULL;
        return false;
    }
    if (item == root->info)
    {
        *loc = root;
        *par = NULL;
        return true;
    }
    if (item < root->info)
        ptr = root->left;
    else
        ptr = root->right;
    ptrsave = root;
    while (ptr != NULL)
    {
        if (item == ptr->info)
        {
            *loc = ptr;
            *par = ptrsave;
            return true;
        }
        ptrsave = ptr;
        if (item < ptr->info)
            ptr = ptr->left;
	else
	    ptr = ptr->right;
    }
    *loc = NULL;
    *par = ptrsave;
}


//Inserting an element to the tree

bool BST::insert(node *tree, node *newnode)
{
    if (root == NULL)
    {
        root = new node;
        root->info = newnode->info;
        root->left = NULL;
        root->right = NULL;
        cout<<"Root Node is Added"<<endl;
        return true;
    }
    if (tree->info == newnode->info)
    {
        cout<<"Element already in the tree"<<endl;
        return false;
    }
    if (tree->info > newnode->info)
    {
        if (tree->left != NULL)
        {
            insert(tree->left, newnode);	
	}
	else
	{
            tree->left = newnode;
            (tree->left)->left = NULL;
            (tree->left)->right = NULL;
            cout<<"Node Added To Left"<<endl;
            returntrue;
        }
    }
    else
    {
        if (tree->right != NULL)
        {
            insert(tree->right, newnode);
        }
        else
        {
            tree->right = newnode;
            (tree->right)->left = NULL;
            (tree->right)->right = NULL;
            cout<<"Node Added To Right"<<endl;
            return true;
        }	
    }
}

//Delete an element from the tree

void BST::del(int item)
{
    node *parent, *location;
    if (root == NULL)
    {
        cout<<"Tree empty"<<endl;
        return;
    }
    find(item, &parent, &location);
    if (location == NULL)
    {
        cout<<"Item not present in tree"<<endl;
        return;
    }
    if (location->left == NULL && location->right == NULL)
        case_a(parent, location);
    if (location->left != NULL && location->right == NULL)
        case_b(parent, location);
    if (location->left == NULL && location->right != NULL)
        case_b(parent, location);
    if (location->left != NULL && location->right != NULL)
        case_c(parent, location);
    free(location);
}

// PreOrder output

void BST::preorder(node *ptr)
{
    if (root == NULL)
    {
        cout<<"Tree is empty"<<endl;
        return;
    }
    if (ptr != NULL)
    {
        cout<<ptr->info<<"  ";
        preorder(ptr->left);
        preorder(ptr->right);
    }
}

// InOrder output

void BST::inorder(node *ptr)
{
    if (root == NULL)
    {
        cout<<"Tree is empty"<<endl;
        return;
    }
    if (ptr != NULL)
    {
        inorder(ptr->left);
        cout<<ptr->info<<"  ";
        inorder(ptr->right);
    }
}

 
/*
 * Case A
 */
void BST::case_a(node *par, node *loc )
{
    if (par == NULL)
    {
        root = NULL;
    }
    else
    {
        if (loc == par->left)
            par->left = NULL;
        else
            par->right = NULL;
    }
}
 
/*
 * Case B
 */
void BST::case_b(node *par, node *loc)
{
    node *child;
    if (loc->left != NULL)
        child = loc->left;
    else
        child = loc->right;
    if (par == NULL)
    {
        root = child;
    }
    else
    {
        if (loc == par->left)
            par->left = child;
        else
            par->right = child;
    }
}
 
/*
 * Case C
 */
void BST::case_c(node *par, node *loc)
{
    node *ptr, *ptrsave, *suc, *parsuc;
    ptrsave = loc;
    ptr = loc->right;
    while (ptr->left != NULL)
    {
        ptrsave = ptr;
        ptr = ptr->left;
    }
    suc = ptr;
    parsuc = ptrsave;
    if (suc->left == NULL && suc->right == NULL)
        case_a(parsuc, suc);
    else
        case_b(parsuc, suc);
    if (par == NULL)
    {
        root = suc;
    }
    else
    {
        if (loc == par->left)
            par->left = suc;
        else
            par->right = suc;
    }
    suc->left = loc->left;
    suc->right = loc->right;
}