4

I am trying to create a function which returns the mirrored copy of a binary tree. By "mirrored" I mean a tree with each left node as its right node and vice versa.

Visual example from the page I'm taking this exercise from.

The one on the left gets copied to resemble the one on the right. This is the code of the function, with the definition of the binary nodes and "insert node" function that I use:

typedef struct bNode {
    int data;
    struct bNode *left;
    struct bNode *right;
} bNode;
    
//  =============================================================
    
bNode* reverse_tree (bNode **tree) {
    bNode *copy = malloc(sizeof(bNode));
    copy->data = (*tree)->data;
    if (!((*tree)->right) && !((*tree)->left)){
        return copy;
    }
        
    copy->left = reverse_tree(&(*tree)->right);
    copy->right = reverse_tree(&(*tree)->left);
    return copy;
}
    
//  =============================================================
    
void insert(bNode **tree, int data) {
    bNode *temp, *previous, *current;

    if (*tree == NULL) {
        temp = (bNode *) malloc(sizeof (bNode));
        temp->data = data;
        temp->left = NULL;
        temp->right = NULL;
        *tree = temp;
        return;
    }

    if (data < (*tree)->data) {
        insert(&(*tree)->left, data);
    } else if (data > (*tree)->data) {
        insert(&(*tree)->right, data);
    }
}

After some troubleshooting, one single layer of recursion works fine, but after that, the pointers break (that is, they point to an inaccessible part of memory), and the program receives a SIGSEGV Segmentation fault.

Why do I receive this SIGSEGV and how do I avoid it?

P.S I am quite inexperienced with pointers; I hope it's not too bad.

(The one on the left gets copied to resemble the one on the right)

Vlad from Moscow
  • 301,070
  • 26
  • 186
  • 335
user8719796
  • 43
  • 6
  • Paste the image directly into the post instead of leaving it as a link. The mountain shaped edit tool will allow you to do this. – ryyker Jun 07 '22 at 13:22
  • `if (!((*tree)->right) && !((*tree)->left)){ return copy; }` If you return here, what happens to all the pointers within `*copy`? What addresses will they point to? – Gerhardh Jun 07 '22 at 13:26
  • ...also, please provide examples of how you are calling each of the functions. Something akin to a [mcve] – ryyker Jun 07 '22 at 13:28
  • As you make a copy and don't modify your tree, there is no need to use `bNode **tree` in `reverse_tree`. A single pointer is sufficient. Also some extra hint in addition to my previous comment: `malloc` does not initialize any memory to 0. – Gerhardh Jun 07 '22 at 13:43
  • @Gerhardh Both children pointers are random values in memory, I know, but right now the problem is the signal that gets thrown, my function doesn't even return once for now. – user8719796 Jun 07 '22 at 14:21
  • @Gerhardh And can't I just `calloc(1,sizeof(bNode))` instead of using malloc? – user8719796 Jun 07 '22 at 14:23
  • Yes, you can use `calloc`. Or you could assign `NULL` explicitely. – Gerhardh Jun 07 '22 at 14:31
  • I did, as expected, nothing changed, but thanks, at least I don't have to think about that anymore. – user8719796 Jun 07 '22 at 14:37

1 Answers1

5

At least the function reverse_tree has a bug.

The sub-statement of this if statement:

if (!((*tree)->right) && !((*tree)->left)){
    return copy;
}

gets the control when the both pointers, right and left, are null pointers.

So this code snippet:

copy->left = reverse_tree(&(*tree)->right);
copy->right = reverse_tree(&(*tree)->left);

can get the control when only one of the pointers is a null pointer.

In this case in the next recursive call of the function this statement:

copy->data = (*tree)->data;

invokes undefined behavior for the passed null pointer.

halfer
  • 19,824
  • 17
  • 99
  • 186
Vlad from Moscow
  • 301,070
  • 26
  • 186
  • 335
  • Thanks, turns out i needed to check for singular NULL pointer cases when swapping nodes, because one of the children might have an invalid pointer, so it needs to ignore the swaps for that particular one. – user8719796 Jun 07 '22 at 14:58