Segmentation fault when accessing BST child nodes. Why? - c++

Question

Segmentation faults occurring in function tdeleteLeft(x) when i try to access (x->left) in definition below:
void BST::tdeleteLeft(Node* x){
if (x->left == NULL){
tdelete(x);
}
else{
Node* y;
y = max(x->left);
tdelete(x->left);
x = y;}
}
And here is the full program:
#include <iostream>
#include <ctime>
#include <cstdlib>
#include <iostream>
using namespace std;
class BST {
public:
typedef struct node {
int value;
struct node *left;
struct node *right;
node() {
left = NULL;
right = NULL;
}
}Node;
Node *root;
Node* i;
Node* y;
int z;
static int c;
int count();
void inc();
BST(int n);
void tdelete(Node* x);
Node* max(Node* x);
void remove_node(Node* x);
Node* min(Node* x);
void tdeleteLeft(Node* x);
void insert(Node* tree, int val);
};
int main ()
{
// create BST tree with n nodes
BST *tree = new BST(10);
clock_t t;
t = clock();
tree->remove_node(tree->root);
t = clock() - t;
cout << t << " clicks " << ((float)t)/CLOCKS_PER_SEC << "seconds).\n" << endl;
return 0;
}
BST::BST(int n){
c = 1;
z = 0;
Node *root = NULL;
for (int i=0; i<n; i++){
int rando = rand() % 10;
insert(root, rando);
}
cout << "created " << n << "-node BST" << endl;
}
int BST::c;
int BST::count(){
return c;
}
void BST::inc(){
c++;
}
BST::Node* BST::max(Node* x){
if (x->right == NULL){
return x;
}
else
return max(x->right);
}
BST::Node* BST::min(Node* x){
Node* i = x;
while (i->left !=NULL){
i = i->left;
}
return i ;
}
void BST::tdelete(Node* x){
if (x->right!=NULL){
tdelete(x->right);
}
if (x->left!=NULL){
tdelete(x->left);
}
delete(x);
}
void BST::tdeleteLeft(Node* x){
if (x->left == NULL){
tdelete(x);
}
else{
Node* y;
y = max(x->left);
tdelete(x->left);
x = y;}
}
void BST::remove_node(Node* x){
tdeleteLeft(x);
}
void BST::insert(Node *tree, int val){
if(tree==NULL){
BST::Node* tree = new BST::Node();
tree->left = NULL;
tree->right = NULL;
tree->value = val;
c++;
}
else{
if(c%2==0){
insert(tree->left, val);}
else
insert(tree->right, val);}
}

Answer 1

For one thing, the following declaration of the local variable root in BST::BST(int)
BST::BST(int n){
c = 1;
z = 0;
Node *root = NULL; // <--- This defines a local variable which shadows BST::root
for (int i=0; i<n; i++){
...
shadows the member of the same name. Correspondingly, tree->root in main remains uninitialized after the call to the constructor.
As a result tree->remove_node(tree->root) attempt to delete the "left" node of an uninitialized pointer, which result in the segmentation fault you are observing. To resolve that problem, you need to remove the local declaration of the root variable:
BST::BST(int n){
c = 1;
z = 0;
for (int i=0; i<n; i++){
...
Then you should note that insert(root, rando) does not update the root variable in the caller context since the pointer is passed by value, so the allocated tree nodes become unreachable. To prevent this, you could either return the updated root node with:
Node* BST::insert(Node* tree, int val){
if(tree==NULL){
tree = new BST::Node(); // careful about shadowing the "tree" argument
...
}
else{
if(c%2==0){
tree->left = insert(tree->left, val);
}
else{
tree->right = insert(tree->right, val);
}
}
return tree;
}
which you'd call in the constructor like so:
BST::BST(int n){
c = 1;
z = 0;
for (int i=0; i<n; i++){
int rando = rand() % 10;
root = insert(root, rando);
}
}
or pass the pointer by reference:
void BST::insert(Node*& tree, int val){
...
}