Access violation. RB tree not creating node correctly - c++

Question

I have an RB tree. It correctly inserts the first node at the root, but when stepping through on the debugger it does not create the next nodes, and when trying to set the parent pointer causes an access violation because it failed to create the node whose parent node pointer it is trying to set.
Source code:
core.h
#include <iostream>
#ifndef CORE_H_
#define CORE_H_
struct node {
public:
node(double);
bool color; //false = red, true = black
double key_value;
node *left_child;
node *right_child;
node *parent;
};
class red_black_tree {
public:
red_black_tree();
~red_black_tree();
void print_tree();
void insert(double key);
// node *search(double key);
// void delete_leaf(double key);
private:
node *root;
node *get_uncle(node *);
node *get_grand(node *);
void insert_case1(node *);
void insert_case2(node *);
void insert_case3(node *);
void insert_case4(node *);
void insert_case5(node *);
void rotate_left(node *);
void rotate_right(node *);
void insert(node *leaf, double key);
//node *search(node *leaf, double key);
// void delete_leaf(double key);
void print_tree(node *leaf);
void destroy_tree(node *leaf);
};
#endif
core.cpp
#include "core.h"
#include <iostream>
node::node(double key) {
left_child = right_child = parent = nullptr;
color = false;
key_value = key;
}
red_black_tree::red_black_tree() {
root = nullptr;
}
red_black_tree::~red_black_tree() {
if (root != nullptr) {
destroy_tree(root);
}
}
void red_black_tree::destroy_tree(node *leaf) {
if (leaf->left_child!= nullptr) {
destroy_tree(leaf->left_child);
}
if (leaf->left_child != nullptr) {
destroy_tree(leaf->right_child);
}
delete leaf;
}
node *red_black_tree::get_grand(node *leaf) {
if (leaf->parent != nullptr && leaf->parent->parent != nullptr)
return leaf->parent->parent;
else return nullptr;
}
node *red_black_tree::get_uncle(node *leaf) {
node *g = get_grand(leaf);
if (g == nullptr)
return nullptr;
if (leaf->parent == g->left_child)
return g->right_child;
else return g->left_child;
}
void red_black_tree::insert(double key) {
if (root == nullptr) {
root = new node(key);
insert_case1(root);
}
else insert(root, key);
}
void red_black_tree::insert(node *leaf, double key) {
//normal recursive binary tree insertion
if (leaf == nullptr) {
leaf = new node(key);
}
else if (key < leaf->key_value) {
insert(leaf->left_child, key);
leaf->left_child->parent = leaf;
insert_case1(leaf);
}
else if (key >= leaf->key_value) {
insert(leaf->right_child, key);
leaf->right_child->parent = leaf;
insert_case1(leaf);
}
}
void red_black_tree::rotate_left(node *leaf) {
node *grand = get_grand(leaf), *s_parent = grand->left_child, *left = leaf->left_child;
grand->left_child = leaf;
leaf->left_child = s_parent;
s_parent->right_child = left;
s_parent->parent = leaf;
leaf->parent = grand;
}
void red_black_tree::rotate_right(node *leaf) {
node *grand = get_grand(leaf), *s_parent = grand->right_child, *right = leaf->right_child;
grand->right_child = leaf;
leaf->right_child = s_parent;
s_parent->left_child = right;
s_parent->parent = leaf;
leaf->parent = grand;
}
void red_black_tree::insert_case1(node * leaf) {
if (leaf->parent == nullptr) {
leaf->color = true;
}
else {
insert_case2(leaf);
}
}
void red_black_tree::insert_case2(node *leaf) {
if (leaf->parent->color == true) {
return;
}
else
insert_case3(leaf);
}
void red_black_tree::insert_case3(node *leaf) {
node *uncle = get_uncle(leaf), *grand;
if ((uncle != nullptr) && (uncle->color == false)) {
leaf->parent->color = true;
uncle->color = true;
grand = get_grand(leaf);
grand->color = false;
insert_case1(grand);
}
else {
insert_case4(leaf);
}
}
void red_black_tree::insert_case4(node *leaf) {
node *grand = get_grand(leaf);
if ((leaf == leaf->parent->right_child) && (leaf->parent == grand->left_child)) {
rotate_left(leaf);
leaf = leaf->left_child;
}
else if ((leaf == leaf->parent->left_child) && (leaf->parent == grand->right_child)) {
rotate_right(leaf);
leaf = leaf->right_child;
}
insert_case5(leaf);
}
void red_black_tree::insert_case5(node *leaf) {
node *grand = get_grand(leaf);
leaf->parent->color = true;
grand->color = false;
if (leaf == leaf->parent->right_child) {
rotate_right(grand);
}
else
rotate_left(grand);
}
void red_black_tree::print_tree() {
print_tree(this->root);
}
void red_black_tree::print_tree(node *leaf) {
if (leaf != nullptr) {
print_tree(leaf->left_child);
std::cout << leaf->key_value;
print_tree(leaf->right_child);
}
}
main.cpp
#include "core.h"
int main() {
red_black_tree tree;
tree.insert(10);
tree.insert(5);
tree.insert(15);
tree.print_tree();
system("pause");
}
Ok, so in the example main(), the first insertion tree.insert(10), works, it calls the non recursive insert, which determines the root is NULL and then sets the root pointer to a new node with the key of 10. The second tree.insert(5), calls the non recursive insert, determines the root exists, and then calls the recursive insert insert(root, 5). This determines that the root is not NULL, then goes to the first of the if/else statements, and recursively calls insert like insert(root->left_child, 5). This determines that root->left_child is NULL and creates a new node at the address for root->left_child. The function then goes back up to the original insert call and tries to set the left child's parent to the root, causing an access violation because somehow the left child was not set. Why isn't the insert function setting the node, my debugger says when I step through that the node is created at the last level of recursion using leaf = new node(5), but when it steps back out a level the node is still NULL at that address?

Answer 1

Look at this part of your code:
void red_black_tree::insert(node *leaf, double key) {
//normal recursive binary tree insertion
if (leaf == nullptr) {
leaf = new node(key);
}
else if (key < leaf->key_value) {
insert(leaf->left_child, key);
leaf->left_child->parent = leaf;
insert_case1(leaf);
} ...
What happens at insert(5) in main?
The second if condition succeeds, so you call insert(leaf->left_child, key), but since the leaf here is the root, it does not have any children yet, so we enter again the same method with leaf = nullptr. When leaf == nullptr (the first if condition), you just create a node but you do not attach it anywhere to your tree.
This explains why you are having this pattern. Now the whole process of tree creation needs rethinking. The problem is that almost everywhere any node has a non-null left and right children.