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();

}