Ancient Dragon
Retired & Loving It
Team Colleague
30,049 posts since Aug 2005
Reputation Points: 5,662
Solved Threads: 2,343
Have something to say? Contribute New Article Reply to this Article
errors in code
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
<code>
<pre><code>#include &lt;iostream&gt;
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&amp; bst);
~BST ();
BST&amp; operator = (BST&amp; 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&amp; bst) {
root = bst.root;
size = bst.size;
}
/*************************************/
// Destructor
BST::~BST () {
// delete root until tree is empty
}
// Assignment Operator
BST&amp; BST::operator = (BST&amp; 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-&gt;key = key;
newNode-&gt;left = NULL;
newNode-&gt;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 = &amp;root;
while (*walker) {
if ((*walker)-&gt;key &gt; newNode-&gt;key)
walker = &amp;((*walker)-&gt;left);
else if ((*walker)-&gt;key &lt; newNode-&gt;key)
walker = &amp;((*walker)-&gt;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 = &amp;root;
while (*walker) {
if ((*walker)-&gt;key == key)
break;
else if ((*walker)-&gt;key &gt; key)
walker = &amp;((*walker)-&gt;left);
else
walker = &amp;((*walker)-&gt;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-&gt;left) {
// find right-most child of left subtree
BSTNode** rtMostOfLeftSubtree = &amp;(eliminationNode-&gt;left);
while (*rtMostOfLeftSubtree)
rtMostOfLeftSubtree = &amp;((*rtMostOfLeftSubtree)-&gt;right);
// link right-most child of left subtree to right of target deletion
*rtMostOfLeftSubtree = eliminationNode-&gt;right;
// bypass target deletion
*walker = eliminationNode-&gt;left;
}
// CASE II - no left-subtree
else {
// bypass target deletion
*walker = eliminationNode-&gt;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 &lt;&lt; &quot;Pre-Order Traversal&quot; &lt;&lt; endl;
preOrderTraversal(root);
cout &lt;&lt; &quot;\b\b &quot; &lt;&lt; endl &lt;&lt; endl;
}
// preOrderTraversal (private): traverses tree by preOrder
void BST::preOrderTraversal (BSTNode* subRoot) {
// base case
if (!subRoot)
return;
// recursive method
// process node
cout &lt;&lt; subRoot-&gt;key &lt;&lt; &quot;, &quot;;
// move left
preOrderTraversal(subRoot-&gt;left);
// move right
preOrderTraversal(subRoot-&gt;right);
}
// inOrderTraversal (public): calls private inOrderTraversal
void BST::inOrderTraversal () {
cout &lt;&lt; &quot;In-Order Traversal&quot; &lt;&lt; endl;
inOrderTraversal(root);
cout &lt;&lt; &quot;\b\b &quot; &lt;&lt; endl &lt;&lt; endl;
}
// inOrderTraversal (private): traverses tree by inOrder
void BST::inOrderTraversal (BSTNode* subRoot) {
//base case
if (subRoot == NULL)
return;
//rec case
//go right
inOrderTraversal(subRoot-&gt;left());
//go left
cout &lt;&lt; subRoot-&gt;key &lt;&lt; &quot;, &quot;;
//process
inOrderTraversal(subRoot-&gt;right());
}
// postOrderTraversal (public): calls private postOrderTraversal
void BST::postOrderTraversal () {
cout &lt;&lt; &quot;Post-Order Traversal&quot; &lt;&lt; endl;
postOrderTraversal(root);
cout &lt;&lt; &quot;\b\b &quot; &lt;&lt; endl &lt;&lt; endl;
}
// postOrderTraversal (private): traverses tree by postOrder
void BST::postOrderTraversal (BSTNode* subRoot) {
//base case
if (subRoot == NULL)
return;
//rec case
//go left
postOrderTraversal(subRoot-&gt;left());
//go right
postOrderTraversal(subRoot-&gt;right());
cout &lt;&lt; subRoot-&gt;key &lt;&lt; &quot;, &quot;;
}
/****************************/
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();
}</code></pre></code>This article has been dead for over three months
You
© 2012 DaniWeb® LLC
