I have two problems with this BST. The first is my delete node function
locks up and I an not sure why. The wecone is I ave to use a template
to do a levelorder Tranverse and I don't have a clue about templates
and what code should go where. The way I have the template code I get a
unresolved external error. Can anyone give me a clue on this? How do I
input the text file into the template?

#include
#include
#include

#include"BSTTreeAndyJackson.cpp"



using namespace std;

//template

int main()
{
btree bt;
int num=0;
char chr;
int count=0;

fin.open("input.txt");
fout.open("output1.txt");


/*struct link {
link* l, r;
int num;
}


template
void traverse(link h, void visit(link)) // perhaps visit should take a T (the type of a data) rather than a link (the type of link)
{ QUEUE q(max);
q.put(h);
while (!q.empty())
{
visit(h = q.get());
if (h--->l != 0) q.put(h--->l);
if (h--->r != 0) q.put(h--->r);
}
}

*/

// ifstream fin;
// ofstream fout;




fin-->-->num;
fin-->-->chr;

while(!fin.eof())

{

count++;
fout-->num;
fin-->-->chr;

}



return 0;
}

Implementation file
#include"BSTTreeAndyJackson.h"
#include

ifstream fin;
ofstream fout;

//Constructor
///////////////////////////////////////////////////////////////////////
btree::btree()
{
root=NULL;
}
//Destructor
//////////////////////////////////////////////////////////////////////
btree::~btree()
{

destroy_tree();

}
//Delete Node
//////////////////////////////////////////////////////////////////////
void btree::deletenode(node *leaf)
{
delete leaf;
}
//Delete Node
//////////////////////////////////////////////////////////////////////
void btree::deletenode()
{
if(root != NULL)
deletenode(root);

else

return;

}
//Destriy tree function
//////////////////////////////////////////////////////////////////////
void btree::destroy_tree(node *leaf)
{
if(leaf!=NULL)
{
destroy_tree(leaf--->left);
destroy_tree(leaf--->right);
delete leaf;
}
}
//Destroy Tree
//////////////////////////////////////////////////////////////////////
void btree::destroy_tree()
{

if(root != NULL)
destroy_tree(root);

else

return;
}
//Insert Tree
//////////////////////////////////////////////////////////////////////
void btree::insert(int key, node *leaf)
{
if(keykey_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

}
}
}




///////////////////////////////////////////////////////////////////////

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;
}
}



//////////////////////////////////////////////////////////////////////

void btree::InOrderTranverse(node *leaf)
{

if(leaf--->left != NULL)
InOrderTranverse(leaf--->left);

foutkey_valueright !=NULL)
InOrderTranverse(leaf--->right);
}
//////////////////////////////////////////////////////////////////////
void btree::InOrderTranverse()
{
if(root!=NULL)
InOrderTranverse(root);
else

return;
}
//////////////////////////////////////////////////////////////////////
void btree::preOrderTranverse(node *leaf)
{
if(leaf != NULL){

foutkey_valueleft);
preOrderTranverse(leaf--->right);
}
}

///////////////////////////////////////////////////////////////////////
void btree::preOrderTranverse()
{
if(root!=NULL)
preOrderTranverse(root);
else

return;
}
//PostOrder
//////////////////////////////////////////////////////////////////////
void btree::PostOrderTranverse()
{
if(root!=NULL)
PostOrderTranverse(root);
else

return;
}

//Post Order Tranverse
//////////////////////////////////////////////////////////////////////
void btree::PostOrderTranverse(node *leaf)
{
if(leaf != NULL){
PostOrderTranverse(leaf--->left);
PostOrderTranverse(leaf--->right);
foutkey_value

struct node;

typedef node *Nodeptr;

struct node
{
int key_value;
node *left;
node *right;
node *leaf;
};


class btree
{
public:
btree();
~btree();
void insert(int key);
void InOrderTranverse();
void preOrderTranverse();
void PostOrderTranverse();
void destroy_tree();
void deletenode();
//int Print(ofstream& fout) const;

private:
void insert(int key, node *leaf);
void InOrderTranverse(node *leaf);
void preOrderTranverse(node *leaf);
void PostOrderTranverse(node *leaf);
void destroy_tree(node *leaf);
void deletenode(node *leaf);
//Nodeptr *root; ;
node *root;

};

Gotta post with HTML disabled, or I can't see the things inside the angled brackets.

Here is an example dealing with the templates.

#include <iostream>
using std::cout;

template <class T> struct BSTlink {
BSTlink<T>*right;
BSTlink<T>*left;
T data;
};

template <class T> void func(T l) {
cout << "The value is " << l << endl;
}

template <class T> void visit (BSTlink<T> lnk, void function(T)) {
function(lnk.data);
}

int main() {
BSTlink<double> blah;
blah.data = 5.0;
visit(blah, func);
return 0;
}