linker error 2019

[sponge268]

I keep getting an lnk2019 error with the following code.

driver.cpp

	  //Author:Wesley McCulloch
      //Section:01
      //Date:October 9, 2008
    
#include <string>
#include <stack>
#include <fstream>
#include "avl.h"
#include "bst.h"
#include "btree.h"

using namespace std;

int main()
{

AVL<string> tree;
string word;
string deleteword;
ifstream dictionarytest ("dictionarytest.txt");

while(!dictionarytest.eof())
{
	dictionarytest >> word;
	bstree.insertNode(word);
}

tree.inOrder();
cout << endl;
tree.preOrder();
cout << endl;
tree.postOrder();
cout << endl;
cout << endl << tree.height()<<endl;
cin >> deleteword;

tree.remove(deleteword);

tree.inOrder();
cout<< endl;

tree.preOrder();

cout << endl;

tree.postOrder();



cout << endl << tree.height()<<endl;



dictionarytest.close();

return 0;
}

avl.h

	  //Author:Wesley McCulloch
      //Section:01
      //Date:October 9, 2008
    
#include <string>
#include <stack>
#include <fstream>
#include "avl.h"
#include "bst.h"
#include "btree.h"

using namespace std;

int main()
{

AVL<string> bstree;
string word;
string deleteword;
ifstream dictionarytest ("dictionarytest.txt");

while(!dictionarytest.eof())
{
	dictionarytest >> word;
	bstree.insertNode(word);
}

bstree.inOrder();
cout << endl;
bstree.preOrder();
cout << endl;
bstree.postOrder();
cout << endl;
cout << endl << bstree.height()<<endl;
cin >> deleteword;

bstree.remove(deleteword);

bstree.inOrder();
cout<< endl;

bstree.preOrder();

cout << endl;

bstree.postOrder();



cout << endl << bstree.height()<<endl;



dictionarytest.close();

return 0;
}

bst.h

#ifndef BST_H
#define BST_H
#include <iostream>
#include <string>
#include <cstdlib>
#include <stack>
#include <fstream>
#include <algorithm>
#include <vector>
#include <queue>
#include <time.h>

template <class T>
class BST
{
	protected:
		struct Node
		{
			Node *left;
			Node *right;
			T value;
			int balance;
		};

		Node *root;
		virtual void insert(Node *&, Node *&);
		virtual void destroySubTree(Node *);
		virtual void deleteNode(T, Node *&);
		virtual void makeDeletion(Node *&);
		void inOrder(Node *) const;
		void preOrder(Node *) const;
		void postOrder(Node *) const;
		
		int numNodes;
		
		int rec_height(Node *);
		
		
	public:
		 BST();
		 ~BST();
		virtual void insertNode(T);
		virtual void remove(T);
		bool searchNode(T);
		void inOrder() const
			{ inOrder(root);}

		void preOrder() const
			{ preOrder(root);}

		void postOrder() const
			{ postOrder(root);}
		int height();
		
};

	//Constructor
	template <class T>
	BST<T>::BST()
	{
		root = NULL;
	}

	//Destructor
	template <class T>
	BST<T>::~BST()
	{
		destroySubTree(root);
	}
	
	//insert
	template <class T>
	void BST<T>::insert(Node *&nodePtr, Node *&newNode)
	{
		if (nodePtr == NULL)
			nodePtr = newNode;
		else if (newNode->value < nodePtr ->value)
			insert(nodePtr->left, newNode);
		else
			insert(nodePtr->right, newNode);
		numNodes ++;

	}

	//insert node
	template <class T>
	void BST<T>::insertNode(T input)
	{
		Node *newNode;
		newNode = new Node;
		newNode->value = input;
		newNode->left = newNode->right = NULL;

		insert(root, newNode);
	}

	//destroySubTree
	template <class T>
	void BST<T>::destroySubTree( Node *nodePtr)
	{
		if(nodePtr)
		{
			if (nodePtr->left)
				destroySubTree(nodePtr->left);
			if (nodePtr->right)
				destroySubTree(nodePtr->right);
			delete nodePtr;
			nodePtr--;
		}
	}

	template <class T>
	bool BST<T>::searchNode(T input)
	{
		Node *nodePtr = root;

		while (nodePtr)
		{
			if (nodePtr->value == input)
				return true;
			else if (input < nodePtr->value)
				nodePtr = nodePtr->left;
			else
				nodePtr = nodePtr->right;
		}
		return false;
	}

	template <class T>
	void BST<T>::remove(T input)
	{
		deleteNode(input, root);
	}

	template <class T>
	void BST<T>::deleteNode(T input, Node *&nodePtr)
	{
		if (input < nodePtr->value)
			deleteNode(input, nodePtr->left);
		else if (input > nodePtr->value)
			deleteNode(input, nodePtr->right);
		else
			makeDeletion(nodePtr);
	}

	template <class T>
	void BST<T>::makeDeletion(Node *&nodePtr)
	{
		Node *tempNodePtr;

			if (nodePtr == NULL)
				cout << "Cannot delete empty node." << endl;
			else if (nodePtr->right == NULL)
			{
				tempNodePtr = nodePtr;
				nodePtr = nodePtr->left;
				delete tempNodePtr;
			}
			else if (nodePtr->left == NULL)
			{
				tempNodePtr = nodePtr;
				nodePtr = nodePtr->right;
				delete tempNodePtr;
			}

			else
			{
				tempNodePtr = nodePtr->right;
				
				while (tempNodePtr->left)
					tempNodePtr = tempNodePtr->left;
				
				tempNodePtr->left = nodePtr->left;
				tempNodePtr = nodePtr;

				nodePtr = nodePtr->right;
				delete tempNodePtr;
				numNodes--;
			}
	}

	template <class T>
	void BST<T>::inOrder(Node *nodePtr) const
	{
		if(nodePtr)
		{
			inOrder(nodePtr->left);
			cout << nodePtr->value <<" ";
			inOrder(nodePtr->right);
		}
	}

	template <class T>
	void BST<T>::preOrder(Node *nodePtr) const
	{
		if(nodePtr)
		{
			cout << nodePtr->value << " ";
			preOrder(nodePtr->left);
			preOrder(nodePtr->right);
		}
	}
	
	template <class T>
	void BST<T>::postOrder(Node *nodePtr) const
	{
		if (nodePtr)
		{
			postOrder(nodePtr->left);
			postOrder(nodePtr->right);
			cout << nodePtr->value << " ";
		}
	}

	template <class T>
	int BST<T>::height()
	{
		return rec_height(root);
	}

	template <class T>
	int BST<T>::rec_height(Node *nodePtr)
	{
		int left=0;
		int right=0;

		if (nodePtr->left)
			left = rec_height(nodePtr->left);

		if (nodePtr->right)
			right = rec_height(nodePtr->right);
		
		if (left > right)
			return 1 + left;
		else
			return 1 + right;
	}
#endif

dictionarytest.txt

a
b
c
d
e
f
g
h
i
j
k
l
m
n
o
p
q
r
s
t
u
v
w
x
y
z

Can anyone please help.