Segmentation fault issues when creating a Binary Search Tree - c++

Question

Ill start out with giving all the code I think is relevant. Basically a Binary Search Tree was already defined that worked and we need to add a parent node functionality. I have done this but I keep getting segmentation faults.
template <class TKey>
class bst {
private:
struct node {
node() { key=TKey(); link[0]=link[1]=NULL; parent=NULL; }
operator TKey () { return key; }
void print();
TKey key;
node *link[2];
node *parent;
};
public:
class iterator {
public:
private:
friend class bst<TKey>;
node *p;
};
node *prev_node;
iterator begin() { }
iterator end() { }
bst() { Troot=NULL; }
~bst() { clear(Troot); }
bool empty() { return Troot==NULL; }
void clear() { clear(Troot); Troot=NULL; }
void erase(TKey &key);
void insert(TKey &key);
void print_inorder() { print_inorder(Troot); }
void print_bylevel();
private:
void clear(node *);
node *minmax_key(node *, int);
node *erase(node *, TKey &);
node *insert(node *, TKey &);
void print_inorder(node *);
node *Troot;
};
Thats the Class Definition.
template <class TKey>
void bst<TKey>::insert(TKey &key)
{
Troot = insert(Troot, key);
}
template <class TKey>
class bst<TKey>::node *bst<TKey>::insert(node *T, TKey &key)
{
cout << "insert1" << endl;
if (T == NULL) {
T = new node;
T->key = key;
if (prev_node != NULL)
T->parent = prev_node;
cout << T->parent->key;
} else if (T->key == key) {
cout << "key " << key << " already in tree" << endl;
} else {
prev_node = T;
int dir = T->key < key;
T->link[dir] = insert(T->link[dir], key);
}
return T;
}
These are the insert functions. Im guessing I am doing something out of order because I am still really rusty with recursion. When I run the test program that uses the tree it outputs the inser1 line but then gives a seg fault. So i know it is messing up on the first insert. any help? If you need to see the rest of the code I can put it up but itll be a lot of stuff that isnt actually relevent to the changes Ive made.

Answer 1

I'm thinking the segfault is on this line
cout << T->parent->key;
If T->parent is null, which it is if T is the newly created root (ie if prev_node == NULL), then you can't access the 'key' of a NULL value.
NOTE: Be aware that I have only skimmed your code, so this is only the first thing I have come across, there could be other bugs.
EDIT:
What do you mean by "I am still having problems", what problems are you having?
It probably isn't how I would implement a BST insert but I can't see anything jumping out saying it is wrong.
How I would implement it is rather than having a global variable prev_node, I would probably change your code like so:
template <class TKey>
void bst<TKey>::insert(TKey &key)
{
// Note that I have an initial prev_node of NULL
Troot = insert(Troot, key, NULL);
}
// Note the extra function parameter
template <class TKey>
class bst<TKey>::node *bst<TKey>::insert(node *T, TKey &key, node *prev_node)
{
cout << "insert1" << endl;
if (T == NULL) {
T = new node;
T->key = key;
// I have a habit of always using braces, so that it is easier to read.
// This would have helped you with your initial problem.
if (prev_node != NULL) {
T->parent = prev_node;
}
//cout << T->parent->key;
} else if (T->key == key) {
cout << "key " << key << " already in tree" << endl;
} else {
int dir = T->key < key;
T->link[dir] = insert(T->link[dir], key, T); // Note diff here
}
return T;
}
Unless you are using prev_node somewhere else.
But this shouldn't change how the insert works, unless in your implementation:
prev_node is not null initially for some reason (which would be the case on successive inserts, unless you are resetting it somewhere else).
something is changing prev_node while you are using it (think thread-safety)