This locks up. I am not sure how I should cll my functions in the client
file to make the BST and do the different functions.PreOrder()etc...
Can someone give me a hint on what I should call?
#include<iostream>
#include<iomanip>
#include<fstream>
#include <cctype> // defines isalpha() function
#include"TreeImplementation.cpp"
using namespace std;
int main()
{
node *temp;
btree bt;
int num=0;
char chr;
int count=0;
int *leaf;
ifstream fin("input.txt");
ofstream fout("output1.txt");
fin>>num;
fin>>chr;
while(fin)
{
temp=bt.insert(num);
//bt.search(num);
bt.InorderTranverse(temp);
fout<<num;
count++;
fout<<"Step: "<<count<<" "<<"Data Value = "<<num<<" "<<"Activity Signal = "<<chr<<endl;
fout<<"Preorder Transversal = "<<endl<<endl;
fout<<"Inorder Transversal = "<<endl<<endl;
fout<<"Post order Transversal = "<<endl<<endl;
fout<<"Level by Level Transversal = "<<endl<<endl;
fout<<"Total Number of nodes = "<<count<<endl<<endl;
fin>>num;
fin>>chr;
}
return 0;
}
header
struct node
{
int key_value;
node *left;
node *right;
};
class btree
{
public:
// node *root;
btree();
// ~btree();
void destroy_tree(node *leaf);
void insert(int key, node *leaf);
node *search(int key, node *leaf);
//node *GetRoot(); {return (root);
//public:
void insert(int key);
node *search(int key);
//void destroy_tree();
void InorderTranverse(node *leaf);
//void preOrderTranverse(node *leaf);
//void PostOrderTranverse(node *leaf);
private:
node *root;
};
node *RChild(node *leaf);
node *LChild(node *leaf);
Implementation
#include<iostream.h>
#include"Treeheader.h"
//Constructor
///////////////////////////////////////////////////////////////////////
btree::btree()
{
root=NULL;
}
///////////////////////////////////////////////////////////////////////
/*btree::~btree()
{
destroy_tree(root);
}
*/
//Destriy tree function
//////////////////////////////////////////////////////////////////////
void destroy_tree(node *leaf)
{
if(leaf!=NULL)
{
destroy_tree(leaf->left);
destroy_tree(leaf->right);
delete leaf;
}
}
//Insert Tree
//////////////////////////////////////////////////////////////////////
void btree::insert(int key, node *leaf)
{
if(key< leaf->key_value)
{
if(leaf->left!=NULL)
insert(key, leaf->left);
else
{
leaf->left=new node;
leaf->left->key_value=key;
leaf->left->left=NULL; //Sets the left child of the child node to null
leaf->left->right=NULL; //Sets the right child of the child node to null
}
}
else if(key>=leaf->key_value)
{
if(leaf->right!=NULL)
insert(key, leaf->right);
else
{
leaf->right=new node;
leaf->right->key_value=key;
leaf->right->left=NULL; //Sets the left child of the child node to null
leaf->right->right=NULL; //Sets the right child of the child node to null
}
}
}
///////////////////////////////////////////////////////////////////////
node *btree::search(int key, node *leaf)
{
if(leaf!=NULL)
{
if(key==leaf->key_value)
return leaf;
if(key<leaf->key_value)
return search(key, leaf->left);
else
return search(key, leaf->right);
}
else return NULL;
}
///////////////////////////////////////////////////////////////////////
void btree::insert(int key)
{
if(root!=NULL)
insert(key, root);
else
{
root=new node;
root->key_value=key;
root->left=NULL;
root->right=NULL;
}
}
//////////////////////////////////////////////////////////////////////
node *btree::search(int key)
{
return search(key, root);
}
///////////////////////////////////////////////////////////////////////
/*void btree::destroy_tree(node *root)
{
if(root != NULL)
destroy_tree(
destroy_tree(root);
}
*/
//////////////////////////////////////////////////////////////////////
void btree::InorderTranverse(node *leaf)
{
if(leaf != NULL)
InorderTranverse(LChild(leaf));
cout<<leaf;
InorderTranverse(RChild(leaf));
}
//////////////////////////////////////////////////////////////////////
node *LChild(node *leaf)
{
return (leaf==NULL) ? NULL : leaf->left;
}
//////////////////////////////////////////////////////////////////////
node *RChild(node *leaf)
{
return (leaf==NULL) ? NULL : leaf->right;
}
//PreOrder Tranverse
///////////////////////////////////////////////////////////////////////
/*void btree:reOrderTranverse(node *leaf)
{
if(leaf != NULL){
cout<<leaf;
preOrderTranverse(LChild(leaf));
preOrderTranverse(RChild(leaf));
}
}
//PostOrderTranverse
///////////////////////////////////////////////////////////////////////
void btree::PostOrderTranverse(node *leaf)
{
if(leaf != NULL){
PostOrderTranverse(LChild(leaf));
PostOrderTranverse(RChild(leaf));
}
}
//////////////////////////////////////////////////////////////////////
node *GetRoot(); {return (root);
{
}*/