Removing an element from BST (pointer error) - c++

Question

So I have my own implementation on BST. Now I need to implement remove_value function, which would remove a node with that value from my tree. I have this simple code:
void binary_tree::remove_value(int value)
{
if (!this->exists(value)) return; //if value doesnt exist - return
nodeBST* current = root;
nodeBST* prev = nullptr;
bool left = true;
while (true)
{
if (current->value == value) // when we find it
{
if (current->right == nullptr && current->left == nullptr) // 0 children
{
delete current;
this->n--;
if (left) prev->left = nullptr;
else prev->right = nullptr;
//even tried delete current here
return;
}
else if (current->right == nullptr && current->left != nullptr) // 1 lewe dziecko
{
if (left) prev->left == current->left;
else prev->right == current->left;
delete current;
this->n--;
return;
}
else if (current->right != nullptr && current->left == nullptr) // 1 prawe dziecko dziecko
{
if (left) prev->left == current->right;
else prev->right == current->right;
delete current;
this->n--;
return;
}
else if (current->right != nullptr && current->left != nullptr) // dwoje dzieci
{
nodeBST* tempNode = findMin(current);
current->value = tempNode->value;
remove_node(current, prev, left);
}
}
else if (current->value > value)
{
prev = current;
left = true;
current = current->left;
}
else
{
prev = current;
left = false;
current = current->right;
}
}
}
I know its kinda mess, so I will tell you what it does. The bottom part is looping through the tree. If the the value we are searching is bigger that the current node value, the previous becomes current, current becomes current->right and left = false. The opposite, when its smaller. Now look that the first if after current->value == value - this is the code which should execute for 0 children. Now, it does delete the current node, but I have a problem.
I have a printing function, which takes a whole tree, and prints it. And it crashes with some pointer error. I checked. When I delete current it sets prev->left or prev->right (depending on left value) to like 0xdddddddd, no matter if I delete after assigning prev-> or before. I even tried to delete prev->right/left and then assign nullptr but still the same happens. How can I make it delete the node, but still be able to assign nullptr to right or left property of prev node?
#Edit:
This code fails on line with print(:
void binary_tree::print(std::string sp, std::string sn, nodeBST* v)
{
if (this->is_empty()) return;
std::string s;
if (v)
{
s = sp;
if (sn == cr) s[s.length() - 2] = ' ';
print(s + cp, cr, v->right);
s = s.substr(0, sp.length() - 2);
std::cout << s << sn << v->value << std::endl;
s = sp;
if (sn == cl) s[s.length() - 2] = ' ';
print(s + cp, cl, v->left);
}
}
The exception is something like (I am translating from my language) that there was unwanted read from memory, and that the v was 0xddddd

Answer 1

So there was a bug inside if (current->right == nullptr && current->left == nullptr). This code is working:
void binary_tree::remove_value(int value)
{
if (!this->exists(value)) return; //if value doesnt exist - return
nodeBST* current = root;
nodeBST* prev = nullptr;
bool left = true;
while (true)
{
if (current->value == value) // when we find it
{
if (current->right == nullptr && current->left == nullptr) // 0 children
{
delete current;
this->n--;
if(prev!=nullptr) {
if (left) prev->left = nullptr;
else prev->right = nullptr;
}
//even tried delete current here
return;
}
else if (current->right == nullptr && current->left != nullptr) // 1 lewe dziecko
{
if(prev!=nullptr) {
if (left) prev->left == current->left;
else prev->right == current->left;}
delete current;
this->n--;
return;
}
else if (current->right != nullptr && current->left == nullptr) // 1 prawe dziecko dziecko
{
if(prev!=nullptr) {
if (left) prev->left == current->right;
else prev->right == current->right;}
delete current;
this->n--;
return;
}
else if (current->right != nullptr && current->left != nullptr) // dwoje dzieci
{
nodeBST* tempNode = findMin(current);
current->value = tempNode->value;
remove_node(current, prev, left);
}
}
else if (current->value > value)
{
prev = current;
left = true;
current = current->left;
}
else
{
prev = current;
left = false;
current = current->right;
}
}
}