c++ - overload [] operator for Red-Black Tree - c++

Question

I'm trying to overload [] for red-black tree. Each node contains four elements: key, gender, height and weight. "key" value will be randomly assigned and should be unique, so I want to overload [] by traversing each node to see if the "key" value already exists. However, it worked only when there was just one node. Here's the code:
#include<iostream>
#include<string>
using namespace std;
enum COLOR { RED, BLACK };
class Node
{
public:
Node(int key, string gender, int height, int weight, const COLOR & color = RED)
:pLeft(NULL), pRight(NULL), pParent(NULL), key(key), gender(gender), height(height), weight(weight), color(color)
{}
~Node();
string getGender();
int getHeight();
int getWeight();
Node* pLeft;
Node* pRight;
Node* pParent;
int key;
string gender;
int height;
int weight;
COLOR color;
};
class RBTree
{
public:
RBTree() :pRoot(NULL) {}
Node &operator[](int key);
bool insert(int key, string gender, int height, int weight);
void RotateL(Node* parent);
void RotateR(Node* parent);
void InOrder();
void InOrder(Node* pRoot);
Node* searchTree(Node* pRoot, int key);
bool CheckRBTree();
bool CheckRBTree(Node* pRoot,int counter,int k);
private:
Node* pRoot;
};
string Node::getGender()
{
return gender;
}
int Node::getHeight()
{
return height;
}
int Node::getWeight()
{
return weight;
}
Node &RBTree::operator[](int key)
{
Node* ptr = searchTree(pRoot, key);
return *ptr;
}
bool RBTree::insert(int key, string gender, int height, int weight)
{
// create root
if (pRoot == NULL)
{
pRoot = new Node(key, gender, height, weight);
pRoot->color = BLACK;
return true;
}
// find loc to insert
Node* pCur = pRoot;
Node* parent = NULL;
while (pCur)
{
if (key < pCur->key)
{
parent = pCur;
pCur = pCur->pLeft;
}
else if (key > pCur->key)
{
parent = pCur;
pCur = pCur->pRight;
}
else
return false;
}
// insert
pCur = new Node(key, gender, height, weight);
if (key < parent->key)
parent->pLeft = pCur;
else
parent->pRight = pCur;
pCur->pParent = parent;
// discuss 3 cases
while (pRoot != pCur&&pCur->pParent->color == RED)
{
Node* gf = parent->pParent;
if (gf->pLeft == parent)
{
Node* uncle = gf->pRight;
if (uncle&&uncle->color == RED)
{
parent->color = BLACK;
uncle->color = BLACK;
gf->color = RED;
pCur = gf;
parent = pCur->pParent;
}
else // turn case 3 into case 2
{
if (parent->pRight == pCur)
{
RotateL(parent);
std::swap(parent, pCur);
}
gf->color = RED;
parent->color = BLACK;
RotateR(gf);
}
}
else
{
Node*uncle = gf->pLeft;
if (uncle && uncle->color == RED) //case 1
{
parent->color = BLACK;
uncle->color = BLACK;
gf->color = RED;
pCur = gf;
parent = pCur->pParent;
}
else // turn case 3 into case 2
{
if (parent->pLeft == pCur)
{
RotateR(parent);
std::swap(parent, pCur);
}
gf->color = RED;
parent->color = BLACK;
RotateL(gf);
}
}
}
pRoot->color = BLACK;
return true;
}
// rotate left
void RBTree::RotateL(Node* parent)
{
Node* subR = parent->pRight;
Node* subRL = subR->pLeft;
parent->pRight = subRL;
if (subRL)
subRL->pParent = parent;
subR->pLeft = parent;
Node* gparent = parent->pParent;
parent->pParent = subR;
subR->pParent = gparent;
if (gparent == NULL)
pRoot = subR;
else if (gparent->pLeft == parent)
gparent->pLeft = subR;
else
gparent->pRight = subR;
}
void RBTree::RotateR(Node* parent)
{
Node* subL = parent->pLeft;
Node* subLR = subL->pRight;
parent->pLeft = subLR;
if (subLR)
subLR->pParent = parent;
subL->pRight = parent;
Node* gparent = parent->pParent;
parent->pParent = subL;
subL->pParent = gparent;
if (gparent == NULL)
pRoot = subL;
else if (gparent->pLeft == parent)
gparent->pLeft = subL;
else
gparent->pRight = subL;
}
void RBTree::InOrder()
{
cout << "InOrder: ";
InOrder(pRoot);
cout << endl;
}
void RBTree::InOrder(Node* pRoot)
{
if (pRoot)
{
InOrder(pRoot->pLeft);
cout << pRoot->key << " ";
InOrder(pRoot->pRight);
}
}
Node* RBTree::searchTree(Node* pRoot, int key)
{
if(pRoot->key == key)
return pRoot;
if(pRoot)
{
cout << "current node is " << pRoot->key << endl;
searchTree(pRoot->pLeft, key);
searchTree(pRoot->pRight, key);
}
return NULL;
}
bool RBTree::CheckRBTree()
{
if (pRoot == NULL)
return true;
if (pRoot->color == RED)
return false;
int blackcount = 0;
Node* pCur = pRoot;
while (pCur)
{
if (pCur->color == BLACK)
blackcount++;
pCur = pCur->pLeft;
}
return CheckRBTree(pRoot, blackcount, 0);
}
bool RBTree::CheckRBTree(Node* pRoot, int counter, int k)
{
if (pRoot == NULL)
return true;
if (pRoot->color == BLACK)
k++;
Node* parent = pRoot->pParent;
if (parent && parent->color == RED && pRoot->color == RED)
return false;
if (pRoot == NULL)
{
if (k != counter)
return false;
}
return CheckRBTree(pRoot->pLeft, counter, k)
&& CheckRBTree(pRoot->pRight, counter, k);
}
int main()
{
int a[] = { 10, 7, 8, 15, 5, 6, 11, 13, 12 };
RBTree t;
for (int index = 0; index < sizeof(a) / sizeof(a[0]); index++)
{
cout << a[index] << " ";
t.insert(a[index], "male", 12, 3);
}
cout << endl;
cout << t[7].getGender() << endl;
return 0;
}
Anyone knows how to fix this? Thanks in advance.

Answer 1

You didn't implement searchTree yet it seems.
Node* RBTree::searchTree(Node* pRoot, int key)
{
if(pRoot->key == key)
return pRoot;
if(pRoot)
{
cout << "current node is " << pRoot->key << endl;
searchTree(pRoot->pLeft, key);
searchTree(pRoot->pRight, key);
}
return NULL;
}
You return the root if it matches and all other cases return NULL. That can't work.
Note: You use pRoot->key and only after that check if(pRoot). If pRoot is NULL you already crashed there.