DaniWeb Forum Index > Software Development > C++

C++ RSS
errors in code

Please support our C++ advertiser: Intel Parallel Studio Home
•
Join Date: Oct 2006
Posts: 22
Reputation: chubbywubba is an unknown quantity at this point
Solved Threads: 0
chubbywubba chubbywubba is offline
Offline
Newbie Poster
errors in code

Feb 5th, 2008
I need help with the assignment operator and destructor, and the deleting by copy. Can someone help me with this? and when i compile just this i get an error on line 219 saying term does not evaluate to a function taking 0 arguments. Does anyone know what this means
 Help with Code Tags 
(Toggle Plain Text)
 Help with Code Tags 
 c++ Syntax (Toggle Plain Text) 
 
#include <iostream>
using namespace std;
 
// Node used in BST
struct BSTNode {
	int key;
	BSTNode* left;
	BSTNode* right;
};
 
// Binary Search Tree
class BST {
private:
	BSTNode* root;
	int size;
 
	bool insert (BSTNode* newNode);
	BSTNode** find (int key);
	void preOrderTraversal (BSTNode* subRoot);
	void inOrderTraversal (BSTNode* subRoot);
	void postOrderTraversal (BSTNode* subRoot);
 
public:
	// Managers
	BST ();
	BST (BST& bst);
	~BST ();
	BST& operator = (BST& bst);
 
	// Accessors
	bool isEmpty ();
	bool isFull ();
	void preOrderTraversal ();
	void inOrderTraversal ();
	void postOrderTraversal ();
 
	// Mutators
	bool insert (int key);
	bool deleteByMerge (int key);
	bool deleteByCopy (int key);
};
 
// default Constructor
BST::BST () {  
	root = NULL;
	size = 0;
}
// Copy Constructor
BST::BST (BST& bst) {
	root = bst.root;
	size = bst.size;
}
 
/*************************************/
// Destructor
BST::~BST () {
	// delete root until tree is empty
}
 
// Assignment Operator
BST& BST::operator = (BST& bst) {
	// ???
	return *this;
}
/***************************************/
// isEmpty: returns if tree is empty
bool BST::isEmpty () { 
	return !root;
}
 
// isFull: returns if memory is available
bool BST::isFull () {
	BSTNode* bogusNode = NULL;
	bogusNode = new BSTNode;
	if (bogusNode) {
		delete bogusNode;
		return false;
	}
	return true; // Note: nothing allocated
}
 
// insert (public): adds a node to tree given key data
bool BST::insert (int key) {
	if (isFull())
		return false;
 
	BSTNode* newNode = new BSTNode;
	newNode->key = key;
	newNode->left = NULL;
	newNode->right = NULL;
	if (insert (newNode))
		return true;
	delete newNode;
	return false;
}
 
// insert (private): adds a node to tree given new-node
bool BST::insert (BSTNode* newNode) {
	BSTNode** walker = &root;
	while (*walker) {
		if ((*walker)->key > newNode->key)
			walker = &((*walker)->left);
		else if ((*walker)->key < newNode->key)
			walker = &((*walker)->right);
		else	// Duplicate of key found
			return false;
	}
	*walker = newNode;
	return true;
}
 
// find (private): returns dbl-pointer to target
BSTNode** BST::find (int key) {
	BSTNode** walker = &root;
	while (*walker) {
		if ((*walker)->key == key)
			break;
		else if ((*walker)->key > key)
			walker = &((*walker)->left);
		else
			walker = &((*walker)->right);
	}
	return walker; // Note: if *walker is NULL, key not found
}
 
// delete (public): using by-merge method: delete node containing key data
bool BST::deleteByMerge (int key) { 
	// find pointer to target deletion
	BSTNode** walker = find(key);
 
	// Determine whether key is found and deletion is to occur
	if (!(*walker)) 
		return false; // deletion failed - target not found
	// keep pointer to node for deletion
	BSTNode*  eliminationNode = *walker; 
 
	//CASE I - left-subtree exists
	if (eliminationNode->left) {
		// find right-most child of left subtree
		BSTNode** rtMostOfLeftSubtree = &(eliminationNode->left);
		while (*rtMostOfLeftSubtree) 
			rtMostOfLeftSubtree = &((*rtMostOfLeftSubtree)->right);
 
		// link right-most child of left subtree to right of target deletion
		*rtMostOfLeftSubtree = eliminationNode->right;
 
		// bypass target deletion
		*walker = eliminationNode->left;
	}
	// CASE II - no left-subtree
	else {
		// bypass target deletion
		*walker = eliminationNode->right;
	}
 
	// delete target
	delete eliminationNode;
 
	// return success of deletion
	return true; // deletion successful
}
 
/****************************/
// delete (public): using by-copy method: delete node containing key data
bool BST::deleteByCopy (int key) {
	// Use code from deleteByMerge where appropriate
 
	// CASE I   - target has no children
	// CASE II  - target has left child, but no right child
	// CASE III - target has right child, but no left child
	// CASE IV  - target has two children
 
	// return success of deletion
	return true; // deletion successful
}
 
// preOrderTraversal (public): calls private preOrderTraversal
void BST::preOrderTraversal () {
	cout << "Pre-Order Traversal" << endl;
	preOrderTraversal(root);
	cout << "\b\b  " << endl << endl;
}
 
// preOrderTraversal (private): traverses tree by preOrder 
void BST::preOrderTraversal (BSTNode* subRoot) {
	// base case
	if (!subRoot)
		return;
 
	// recursive method
	// process node
	cout << subRoot->key << ", ";
	// move left
	preOrderTraversal(subRoot->left);
	// move right
	preOrderTraversal(subRoot->right);
}
 
// inOrderTraversal (public): calls private inOrderTraversal
void BST::inOrderTraversal () {	
	cout << "In-Order Traversal" << endl;
	inOrderTraversal(root);
	cout << "\b\b  " << endl << endl;
}
// inOrderTraversal (private): traverses tree by inOrder
void BST::inOrderTraversal (BSTNode* subRoot) {
		//base case
	if (subRoot == NULL)
		return;
	//rec case
 
	//go right
	inOrderTraversal(subRoot->left());
	//go left
	cout << subRoot->key << ", ";
	//process
	inOrderTraversal(subRoot->right());
}
 
// postOrderTraversal (public): calls private postOrderTraversal
void BST::postOrderTraversal () {
	cout << "Post-Order Traversal" << endl;
	postOrderTraversal(root);
	cout << "\b\b  " << endl << endl;
}
// postOrderTraversal (private): traverses tree by postOrder
void BST::postOrderTraversal (BSTNode* subRoot) {
		//base case
	if (subRoot == NULL)
		return;
	//rec case
 
	//go left
	postOrderTraversal(subRoot->left());
	//go right
	postOrderTraversal(subRoot->right());
 
	cout << subRoot->key << ", ";
 
}
 
/****************************/
void main () {
	BST bst;
	bst.insert(5);
	bst.insert(10);
	bst.insert(3);
	bst.insert(4);
	bst.insert(9);
	bst.insert(7);
	bst.insert(8);
	bst.preOrderTraversal();
	bst.inOrderTraversal();
	bst.postOrderTraversal();
 
}
#include <iostream>
using namespace std;

// Node used in BST
struct BSTNode {
	int key;
	BSTNode* left;
	BSTNode* right;
};

// Binary Search Tree
class BST {
private:
	BSTNode* root;
	int size;

	bool insert (BSTNode* newNode);
	BSTNode** find (int key);
	void preOrderTraversal (BSTNode* subRoot);
	void inOrderTraversal (BSTNode* subRoot);
	void postOrderTraversal (BSTNode* subRoot);

public:
	// Managers
	BST ();
	BST (BST& bst);
	~BST ();
	BST& operator = (BST& bst);

	// Accessors
	bool isEmpty ();
	bool isFull ();
	void preOrderTraversal ();
	void inOrderTraversal ();
	void postOrderTraversal ();

	// Mutators
	bool insert (int key);
	bool deleteByMerge (int key);
	bool deleteByCopy (int key);
};

// default Constructor
BST::BST () {  
	root = NULL;
	size = 0;
}
// Copy Constructor
BST::BST (BST& bst) {
	root = bst.root;
	size = bst.size;
}

/*************************************/
// Destructor
BST::~BST () {
	// delete root until tree is empty
}

// Assignment Operator
BST& BST::operator = (BST& bst) {
	// ???
	return *this;
}
/***************************************/
// isEmpty: returns if tree is empty
bool BST::isEmpty () { 
	return !root;
}

// isFull: returns if memory is available
bool BST::isFull () {
	BSTNode* bogusNode = NULL;
	bogusNode = new BSTNode;
	if (bogusNode) {
		delete bogusNode;
		return false;
	}
	return true; // Note: nothing allocated
}

// insert (public): adds a node to tree given key data
bool BST::insert (int key) {
	if (isFull())
		return false;

	BSTNode* newNode = new BSTNode;
	newNode->key = key;
	newNode->left = NULL;
	newNode->right = NULL;
	if (insert (newNode))
		return true;
	delete newNode;
	return false;
}

// insert (private): adds a node to tree given new-node
bool BST::insert (BSTNode* newNode) {
	BSTNode** walker = &root;
	while (*walker) {
		if ((*walker)->key > newNode->key)
			walker = &((*walker)->left);
		else if ((*walker)->key < newNode->key)
			walker = &((*walker)->right);
		else	// Duplicate of key found
			return false;
	}
	*walker = newNode;
	return true;
}

// find (private): returns dbl-pointer to target
BSTNode** BST::find (int key) {
	BSTNode** walker = &root;
	while (*walker) {
		if ((*walker)->key == key)
			break;
		else if ((*walker)->key > key)
			walker = &((*walker)->left);
		else
			walker = &((*walker)->right);
	}
	return walker; // Note: if *walker is NULL, key not found
}

// delete (public): using by-merge method: delete node containing key data
bool BST::deleteByMerge (int key) { 
	// find pointer to target deletion
	BSTNode** walker = find(key);

	// Determine whether key is found and deletion is to occur
	if (!(*walker)) 
		return false; // deletion failed - target not found
	// keep pointer to node for deletion
	BSTNode*  eliminationNode = *walker; 

	//CASE I - left-subtree exists
	if (eliminationNode->left) {
		// find right-most child of left subtree
		BSTNode** rtMostOfLeftSubtree = &(eliminationNode->left);
		while (*rtMostOfLeftSubtree) 
			rtMostOfLeftSubtree = &((*rtMostOfLeftSubtree)->right);

		// link right-most child of left subtree to right of target deletion
		*rtMostOfLeftSubtree = eliminationNode->right;

		// bypass target deletion
		*walker = eliminationNode->left;
	}
	// CASE II - no left-subtree
	else {
		// bypass target deletion
		*walker = eliminationNode->right;
	}

	// delete target
	delete eliminationNode;

	// return success of deletion
	return true; // deletion successful
}

/****************************/
// delete (public): using by-copy method: delete node containing key data
bool BST::deleteByCopy (int key) {
	// Use code from deleteByMerge where appropriate

	// CASE I   - target has no children
	// CASE II  - target has left child, but no right child
	// CASE III - target has right child, but no left child
	// CASE IV  - target has two children

	// return success of deletion
	return true; // deletion successful
}

// preOrderTraversal (public): calls private preOrderTraversal
void BST::preOrderTraversal () {
	cout << "Pre-Order Traversal" << endl;
	preOrderTraversal(root);
	cout << "\b\b  " << endl << endl;
}

// preOrderTraversal (private): traverses tree by preOrder 
void BST::preOrderTraversal (BSTNode* subRoot) {
	// base case
	if (!subRoot)
		return;

	// recursive method
	// process node
	cout << subRoot->key << ", ";
	// move left
	preOrderTraversal(subRoot->left);
	// move right
	preOrderTraversal(subRoot->right);
}

// inOrderTraversal (public): calls private inOrderTraversal
void BST::inOrderTraversal () {	
	cout << "In-Order Traversal" << endl;
	inOrderTraversal(root);
	cout << "\b\b  " << endl << endl;
}
// inOrderTraversal (private): traverses tree by inOrder
void BST::inOrderTraversal (BSTNode* subRoot) {
		//base case
	if (subRoot == NULL)
		return;
	//rec case

	//go right
	inOrderTraversal(subRoot->left());
	//go left
	cout << subRoot->key << ", ";
	//process
	inOrderTraversal(subRoot->right());
}

// postOrderTraversal (public): calls private postOrderTraversal
void BST::postOrderTraversal () {
	cout << "Post-Order Traversal" << endl;
	postOrderTraversal(root);
	cout << "\b\b  " << endl << endl;
}
// postOrderTraversal (private): traverses tree by postOrder
void BST::postOrderTraversal (BSTNode* subRoot) {
		//base case
	if (subRoot == NULL)
		return;
	//rec case
	
	//go left
	postOrderTraversal(subRoot->left());
	//go right
	postOrderTraversal(subRoot->right());

	cout << subRoot->key << ", ";

}

/****************************/
void main () {
	BST bst;
	bst.insert(5);
	bst.insert(10);
	bst.insert(3);
	bst.insert(4);
	bst.insert(9);
	bst.insert(7);
	bst.insert(8);
	bst.preOrderTraversal();
	bst.inOrderTraversal();
	bst.postOrderTraversal();

}
     Help with Code Tags   c++ Syntax (Toggle Plain Text)     #include <iostream>using namespace std; // Node used in BSTstruct BSTNode {	int key;	BSTNode* left;	BSTNode* right;}; // Binary Search Treeclass BST {private:	BSTNode* root;	int size; 	bool insert (BSTNode* newNode);	BSTNode** find (int key);	void preOrderTraversal (BSTNode* subRoot);	void inOrderTraversal (BSTNode* subRoot);	void postOrderTraversal (BSTNode* subRoot); public:	// Managers	BST ();	BST (BST& bst);	~BST ();	BST& operator = (BST& bst); 	// Accessors	bool isEmpty ();	bool isFull ();	void preOrderTraversal ();	void inOrderTraversal ();	void postOrderTraversal (); 	// Mutators	bool insert (int key);	bool deleteByMerge (int key);	bool deleteByCopy (int key);}; // default ConstructorBST::BST () {  	root = NULL;	size = 0;}// Copy ConstructorBST::BST (BST& bst) {	root = bst.root;	size = bst.size;} /*************************************/// DestructorBST::~BST () {	// delete root until tree is empty} // Assignment OperatorBST& BST::operator = (BST& bst) {	// ???	return *this;}/***************************************/// isEmpty: returns if tree is emptybool BST::isEmpty () { 	return !root;} // isFull: returns if memory is availablebool BST::isFull () {	BSTNode* bogusNode = NULL;	bogusNode = new BSTNode;	if (bogusNode) {		delete bogusNode;		return false;	}	return true; // Note: nothing allocated} // insert (public): adds a node to tree given key databool BST::insert (int key) {	if (isFull())		return false; 	BSTNode* newNode = new BSTNode;	newNode->key = key;	newNode->left = NULL;	newNode->right = NULL;	if (insert (newNode))		return true;	delete newNode;	return false;} // insert (private): adds a node to tree given new-nodebool BST::insert (BSTNode* newNode) {	BSTNode** walker = &root;	while (*walker) {		if ((*walker)->key > newNode->key)			walker = &((*walker)->left);		else if ((*walker)->key < newNode->key)			walker = &((*walker)->right);		else	// Duplicate of key found			return false;	}	*walker = newNode;	return true;} // find (private): returns dbl-pointer to targetBSTNode** BST::find (int key) {	BSTNode** walker = &root;	while (*walker) {		if ((*walker)->key == key)			break;		else if ((*walker)->key > key)			walker = &((*walker)->left);		else			walker = &((*walker)->right);	}	return walker; // Note: if *walker is NULL, key not found} // delete (public): using by-merge method: delete node containing key databool BST::deleteByMerge (int key) { 	// find pointer to target deletion	BSTNode** walker = find(key); 	// Determine whether key is found and deletion is to occur	if (!(*walker)) 		return false; // deletion failed - target not found	// keep pointer to node for deletion	BSTNode*  eliminationNode = *walker;  	//CASE I - left-subtree exists	if (eliminationNode->left) {		// find right-most child of left subtree		BSTNode** rtMostOfLeftSubtree = &(eliminationNode->left);		while (*rtMostOfLeftSubtree) 			rtMostOfLeftSubtree = &((*rtMostOfLeftSubtree)->right); 		// link right-most child of left subtree to right of target deletion		*rtMostOfLeftSubtree = eliminationNode->right; 		// bypass target deletion		*walker = eliminationNode->left;	}	// CASE II - no left-subtree	else {		// bypass target deletion		*walker = eliminationNode->right;	} 	// delete target	delete eliminationNode; 	// return success of deletion	return true; // deletion successful} /****************************/// delete (public): using by-copy method: delete node containing key databool BST::deleteByCopy (int key) {	// Use code from deleteByMerge where appropriate 	// CASE I   - target has no children	// CASE II  - target has left child, but no right child	// CASE III - target has right child, but no left child	// CASE IV  - target has two children 	// return success of deletion	return true; // deletion successful} // preOrderTraversal (public): calls private preOrderTraversalvoid BST::preOrderTraversal () {	cout << "Pre-Order Traversal" << endl;	preOrderTraversal(root);	cout << "\b\b  " << endl << endl;} // preOrderTraversal (private): traverses tree by preOrder void BST::preOrderTraversal (BSTNode* subRoot) {	// base case	if (!subRoot)		return; 	// recursive method	// process node	cout << subRoot->key << ", ";	// move left	preOrderTraversal(subRoot->left);	// move right	preOrderTraversal(subRoot->right);} // inOrderTraversal (public): calls private inOrderTraversalvoid BST::inOrderTraversal () {		cout << "In-Order Traversal" << endl;	inOrderTraversal(root);	cout << "\b\b  " << endl << endl;}// inOrderTraversal (private): traverses tree by inOrdervoid BST::inOrderTraversal (BSTNode* subRoot) {		//base case	if (subRoot == NULL)		return;	//rec case 	//go right	inOrderTraversal(subRoot->left());	//go left	cout << subRoot->key << ", ";	//process	inOrderTraversal(subRoot->right());} // postOrderTraversal (public): calls private postOrderTraversalvoid BST::postOrderTraversal () {	cout << "Post-Order Traversal" << endl;	postOrderTraversal(root);	cout << "\b\b  " << endl << endl;}// postOrderTraversal (private): traverses tree by postOrdervoid BST::postOrderTraversal (BSTNode* subRoot) {		//base case	if (subRoot == NULL)		return;	//rec case 	//go left	postOrderTraversal(subRoot->left());	//go right	postOrderTraversal(subRoot->right()); 	cout << subRoot->key << ", "; } /****************************/void main () {	BST bst;	bst.insert(5);	bst.insert(10);	bst.insert(3);	bst.insert(4);	bst.insert(9);	bst.insert(7);	bst.insert(8);	bst.preOrderTraversal();	bst.inOrderTraversal();	bst.postOrderTraversal(); } 
#include <iostream>
using namespace std;

// Node used in BST
struct BSTNode {
	int key;
	BSTNode* left;
	BSTNode* right;
};

// Binary Search Tree
class BST {
private:
	BSTNode* root;
	int size;

	bool insert (BSTNode* newNode);
	BSTNode** find (int key);
	void preOrderTraversal (BSTNode* subRoot);
	void inOrderTraversal (BSTNode* subRoot);
	void postOrderTraversal (BSTNode* subRoot);

public:
	// Managers
	BST ();
	BST (BST& bst);
	~BST ();
	BST& operator = (BST& bst);

	// Accessors
	bool isEmpty ();
	bool isFull ();
	void preOrderTraversal ();
	void inOrderTraversal ();
	void postOrderTraversal ();

	// Mutators
	bool insert (int key);
	bool deleteByMerge (int key);
	bool deleteByCopy (int key);
};

// default Constructor
BST::BST () {  
	root = NULL;
	size = 0;
}
// Copy Constructor
BST::BST (BST& bst) {
	root = bst.root;
	size = bst.size;
}

/*************************************/
// Destructor
BST::~BST () {
	// delete root until tree is empty
}

// Assignment Operator
BST& BST::operator = (BST& bst) {
	// ???
	return *this;
}
/***************************************/
// isEmpty: returns if tree is empty
bool BST::isEmpty () { 
	return !root;
}

// isFull: returns if memory is available
bool BST::isFull () {
	BSTNode* bogusNode = NULL;
	bogusNode = new BSTNode;
	if (bogusNode) {
		delete bogusNode;
		return false;
	}
	return true; // Note: nothing allocated
}

// insert (public): adds a node to tree given key data
bool BST::insert (int key) {
	if (isFull())
		return false;

	BSTNode* newNode = new BSTNode;
	newNode->key = key;
	newNode->left = NULL;
	newNode->right = NULL;
	if (insert (newNode))
		return true;
	delete newNode;
	return false;
}

// insert (private): adds a node to tree given new-node
bool BST::insert (BSTNode* newNode) {
	BSTNode** walker = &root;
	while (*walker) {
		if ((*walker)->key > newNode->key)
			walker = &((*walker)->left);
		else if ((*walker)->key < newNode->key)
			walker = &((*walker)->right);
		else	// Duplicate of key found
			return false;
	}
	*walker = newNode;
	return true;
}

// find (private): returns dbl-pointer to target
BSTNode** BST::find (int key) {
	BSTNode** walker = &root;
	while (*walker) {
		if ((*walker)->key == key)
			break;
		else if ((*walker)->key > key)
			walker = &((*walker)->left);
		else
			walker = &((*walker)->right);
	}
	return walker; // Note: if *walker is NULL, key not found
}

// delete (public): using by-merge method: delete node containing key data
bool BST::deleteByMerge (int key) { 
	// find pointer to target deletion
	BSTNode** walker = find(key);

	// Determine whether key is found and deletion is to occur
	if (!(*walker)) 
		return false; // deletion failed - target not found
	// keep pointer to node for deletion
	BSTNode*  eliminationNode = *walker; 

	//CASE I - left-subtree exists
	if (eliminationNode->left) {
		// find right-most child of left subtree
		BSTNode** rtMostOfLeftSubtree = &(eliminationNode->left);
		while (*rtMostOfLeftSubtree) 
			rtMostOfLeftSubtree = &((*rtMostOfLeftSubtree)->right);

		// link right-most child of left subtree to right of target deletion
		*rtMostOfLeftSubtree = eliminationNode->right;

		// bypass target deletion
		*walker = eliminationNode->left;
	}
	// CASE II - no left-subtree
	else {
		// bypass target deletion
		*walker = eliminationNode->right;
	}

	// delete target
	delete eliminationNode;

	// return success of deletion
	return true; // deletion successful
}

/****************************/
// delete (public): using by-copy method: delete node containing key data
bool BST::deleteByCopy (int key) {
	// Use code from deleteByMerge where appropriate

	// CASE I   - target has no children
	// CASE II  - target has left child, but no right child
	// CASE III - target has right child, but no left child
	// CASE IV  - target has two children

	// return success of deletion
	return true; // deletion successful
}

// preOrderTraversal (public): calls private preOrderTraversal
void BST::preOrderTraversal () {
	cout << "Pre-Order Traversal" << endl;
	preOrderTraversal(root);
	cout << "\b\b  " << endl << endl;
}

// preOrderTraversal (private): traverses tree by preOrder 
void BST::preOrderTraversal (BSTNode* subRoot) {
	// base case
	if (!subRoot)
		return;

	// recursive method
	// process node
	cout << subRoot->key << ", ";
	// move left
	preOrderTraversal(subRoot->left);
	// move right
	preOrderTraversal(subRoot->right);
}

// inOrderTraversal (public): calls private inOrderTraversal
void BST::inOrderTraversal () {	
	cout << "In-Order Traversal" << endl;
	inOrderTraversal(root);
	cout << "\b\b  " << endl << endl;
}
// inOrderTraversal (private): traverses tree by inOrder
void BST::inOrderTraversal (BSTNode* subRoot) {
		//base case
	if (subRoot == NULL)
		return;
	//rec case

	//go right
	inOrderTraversal(subRoot->left());
	//go left
	cout << subRoot->key << ", ";
	//process
	inOrderTraversal(subRoot->right());
}

// postOrderTraversal (public): calls private postOrderTraversal
void BST::postOrderTraversal () {
	cout << "Post-Order Traversal" << endl;
	postOrderTraversal(root);
	cout << "\b\b  " << endl << endl;
}
// postOrderTraversal (private): traverses tree by postOrder
void BST::postOrderTraversal (BSTNode* subRoot) {
		//base case
	if (subRoot == NULL)
		return;
	//rec case
	
	//go left
	postOrderTraversal(subRoot->left());
	//go right
	postOrderTraversal(subRoot->right());

	cout << subRoot->key << ", ";

}

/****************************/
void main () {
	BST bst;
	bst.insert(5);
	bst.insert(10);
	bst.insert(3);
	bst.insert(4);
	bst.insert(9);
	bst.insert(7);
	bst.insert(8);
	bst.preOrderTraversal();
	bst.inOrderTraversal();
	bst.postOrderTraversal();

}  