Locating predecessor and successor nodes - data-structures

Question

I have a method for getting the successor and predecessor nodes in a binary search tree, but I am having some problems locating the bug in my code. Say I add nodes with the following keys: "C", "B", and "K". If I print the contents of my binary search tree, I get the following output:
"C" "some data 1"
"B" "some data 2"
"K" "some data 3"
When I add "B" it obviously has no predecessor or successor, so I just set those to empty strings:
root = root->insert(root, key, data);
root->getNextAndPrev(root, prev, next, key);
string p;
string n;
if (!prev) {
pred = "";
}
else {
pred = prev->getKey();
}
if (!next) {
succ = "";
}
else {
succ = next->getKey();
}
return new Entry(data, succ, pred);
When I add "B" I get the output that "B"s successor is "C" and the predecessor is "" as expected. However, when I add "K" to the tree, I get the output that "K"s predecessor is "C" and the successor is also "C". I am not sure why I am getting this error since I check to see if there is no successor (nothing coming after "K") set it to an empty string.
My Node class handles the insert() and getNextAndPrev() methods, and here is how I've implemented them:
void Node::getNextAndPrev(Node* root, string key) {
if (!root) return;
if (root->key == key){
if (root->left != NULL){
Node* tempNode = root->left;
while (tempNode->right != NULL) {
tempNode = tempNode->right;
}
prev= tempNode;
}
if (root->right != NULL){
Node* tempNode = root->right;
while (tempNode->left != NULL) {
tempNode = tempNode->left;
}
next = tempNode;
}
}
if (root->key > key) {
next = root;
getNextAndPrev(root->left, key);
}
else {
prev = root;
getNextAndPrev(root->right, key);
}
}
Why is it that by adding some keys out of order causes my getNextAndPrev to retrieve incorrect values?
Perhaps it has something to do with how I am inserting entries in my main. I have a loop set up as follows:
string command = "";
Entry* entry = new Entry("","","");
string def = "";
while (true) {
cout << "Enter command: ";
getline(cin, command);
if (parseCommand(command, "ADD") == 0) {
string tempCmd = processCommand(command, 3);
string key = tempCmd.substr(0, tempCmd.length() - 4);
string data = tempCmd.substr(tempCmd.length() - 4);
trim(key);
trim(data);
def = data;
entry = dict->modify(key, data);
cout << "added: " << key << " with definition of : " << def << " to the dictionary " << endl;
}
modify() gets called like so inside my Dictionary class:
Entry * Dictionary::modify(string key, string data) {
Entry * entry = new Entry("","","");
if (root) entry = search(key);
//inserting something into the dictionary
if (data != "" && !this->root->doesContain(this->root, key)) {
root = root->insert(root, key, data);
return entry;
}
}
And finally, my search() method that gets called inside modify():
Entry * Dictionary::search(string key) {
if (key == "") {
return new Entry("", getSmallestKey(), getLargestKey());
}
if (!this->root->doesContain(root, key)) {
root->getNextAndPrev(root, key);
string prev;
string next;
if (root->getPrevNode() != NULL) {
prev = root->getPrevious();
cout << "Predecessor is " << prev << " root is: " << root->getKey() << endl;
}
else {
prev = "";
cout << "No Predecessor" << endl;
}
if (root->getNextNode() != NULL) {
next = root->getNext();
cout << "Successor is " << next << " root is: " << root->getKey() << endl;
}
else {
next = "";
cout << "No Successor" << endl;
}
if (next == prev) {
if (next < key) {
next = "";
}
if (prev > key) {
prev = "";
}
}
return new Entry("", next, prev);
}
To illustrate the problem in detail, here is the output from running the above:
Enter command: ADD "FOO" "D"
lookup stuff: root: prev: next: // gets logged out when I insert into dictionary
added: "FOO" with a definition of: "D" to the dictionary
Enter command: ADD "BIN" "C"
No Predecessor
Successor is "FOO" root is: "FOO"
lookup stuff: root: prev: next: "FOO"
added: "BIN" with a definition of: "C" to the dictionary
Enter command: ADD "QUUX" "D"
Predecessor is "FOO" root is: "FOO"
Successor is "FOO" root is: "FOO"
lookup stuff: root: prev: "FOO" next:
added: "QUUX" with a definition of: "D" to the dictionary
Enter command: ADD "BAZ" "N"
Predecessor is "FOO" root is: "FOO"
Successor is "BIN" root is: "FOO"
lookup stuff: root: prev: "FOO" next: "BIN"
added: "BAZ" with a definition of: "N" to the dictionary
I can't figure out why when adding BAZ to the dictionary, the predecessor and successor is now out of place:
Enter command: ADD "BAZ" "N"
Predecessor is "FOO" root is: "FOO"
Successor is "BIN" root is: "FOO"

Answer 1

I hope your Node constructor
new Node(key, d)
sets the left and right fields to NULL.
By successor and predecessor I think you mean inorder traversal successor and predecessor. Well your code seems absolutely fine to me
The only possibility is that I think you are using common variables prev and next to get the predecessor and successor. So try using different variables for different nodes.
After you are done getting successor and predecssor for the node B, define new variables:
Node *prevK,*nextK;
and call the function getNextAndPrev() with these variables.