Tree class in C++ - c++

Question

I want to solve a problem regarding numbers saved in a tree structure.
I would like to create one class called Tree and another one called Element (in this case would be an Integer but it could be whatever) and make it the most adequate way based on C++ standards. It should be possible to add childs to a specific element in the tree and traceback the parent of each element.
#include <iostream>
#include <vector>
class Element
{
public:
Element() = delete;
explicit Element(int value, Element* parent = nullptr):
value_(value), parent_(parent), children_() {}
int getValue() const { return value_; }
Element* getParent() { return parent_; }
// it will throw if idx out of bounds
Element* getChild(size_t idx) { return children_.at(idx).get(); }
size_t numChildren() const { return children_.size(); }
Element* insertChild(int value)
{
std::cout << "new elem: " << value << std::endl;
children_.emplace_back(std::make_unique<Element>(value, this));
return children_.back().get();
}
bool moveChildren2Parent()
{
if (isRoot()) return false;
for (auto& c : children_)
{
// children change parent
c->parent_ = parent_;
parent_->children_.emplace_back(std::move(c));
}
children_.clear();
return true;
}
bool removeChild(size_t idx)
{
if (children_.size() <= idx) return false;
children_.erase(children_.begin()+idx);
return true;
}
bool isRoot() { return parent_ == nullptr; }
private:
int value_;
Element* parent_;
std::vector<std::unique_ptr<Element> > children_;
};
void checkChilds(Element* element) {
for (int i = 0; i < element->numChildren(); i++)
{
if (element->getChild(i)->numChildren() == 1)
{
element->getChild(i)->moveChildren2Parent();
element->removeChild(i);
i--;
} else if (element->getChild(i)->numChildren() > 1)
{
checkChilds(element->getChild(i));
}
}
}
int main()
{
auto root = std::make_shared<Element>(0);
Element* _ = root->insertChild(1)->insertChild(3)->insertChild(5);
Element* last_child = root->insertChild(2)->insertChild(4)->insertChild(7);
last_child->getParent()->insertChild(6);
for (int i=0;i<root->numChildren();i++)
{
if (root->getChild(i)->numChildren()==1)
{
root->getChild(i)->moveChildren2Parent();
root->removeChild(i);
i--;
}
else if (root->getChild(i)->numChildren()>1)
{
checkChilds(root->getChild(i));
}
}
return 0;
}
My objective is to create a tree and after if each element just has one child remove that element while keeping the leaves.
My code works but I would like to know improvements to make it better looking based on C++ standards.
EDIT
Thanks to the answer #pptaszni and after adapting it to my specific problem at hand this is the result. I think my implementation to go over all the elements checking if the number of childs they have is equal 1 and if so remove is not nicely written. Do you know how could I optimize it (the last for loop in main and function checkChilds)?

Answer 1

is there any specific reason you need two different class for element and tree?
i suggest, have just one class which have one data member which will store a node value and two pointers to point at two different child objects.
following is the suggestion based on what i have have understood from your question.
class Node
{
int value;
Node* left_child = nullptr;
Node* right_child = nullptr;
//methods for modifying tree.
};

Answer 2

To answer your first question: don't use operator[], because it inserts default-constructed element if it doesn't exist in the map. You can use at instead.
Then about your architecture: it doesn't look very good, because having a child, it's not obvious how to get parent, having a parent, it's not obvious how to get it's children, your std::map key is supposed to be unique and you also use it as a value for your Elements. I suggest to apply at least the following:
class Element
{
public:
Element() = delete;
explicit Element(int value, Element* parent = nullptr):
value_(value), parent_(parent), left_child_(nullptr), right_child_(nullptr) {}
int getValue() const { return value_; }
Element* getParent() { return parent_; }
Element* getLeftChild() { return left_child_.get(); }
Element* getRightChild() { return right_child_.get(); }
Element* insertLeftChild(int value)
{
if (left_child_)
{
std::cout << "already exists" << std::endl;
return left_child_.get(); // already exists
}
std::cout << "new left elem: " << value << std::endl;
left_child_ = std::make_unique<Element>(value, this);
return left_child_.get();
}
bool isRoot() { return parent_ == nullptr; }
private:
int value_;
Element* parent_;
std::unique_ptr<Element> left_child_;
std::unique_ptr<Element> right_child_;
};
int main()
{
auto root = std::make_shared<Element>(1);
Element* last_child = root->insertLeftChild(2)->insertLeftChild(3)->insertLeftChild(4);
std::cout << last_child->getValue() << std::endl;
std::cout << last_child->getParent()->getValue() << std::endl;
std::cout << last_child->getParent()->getParent()->getValue() << std::endl;
std::cout << last_child->getParent()->getParent()->getParent()->getValue() << std::endl;
std::cout << last_child->getParent()->getParent()->getParent()->isRoot() << std::endl;
return 0;
}
Now you have the access to parent and children from every element and you can start building your tree. Then there are further concerns like Element comparison operator (if needed), only 2 children per node or maybe more, pointers invalidation on every tree modification etc. It is a big topic in general.
======= EDIT =========
To answer OP's concern about multiple children, and to provide an example of removing the node while preserving the leaves (children):
class Element
{
public:
Element() = delete;
explicit Element(int value, Element* parent = nullptr):
value_(value), parent_(parent), children_() {}
int getValue() const { return value_; }
Element* getParent() { return parent_; }
// it will throw if idx out of bounds
Element* getChild(size_t idx) { return children_.at(idx).get(); }
size_t numChildren() const { return children_.size(); }
Element* insertChild(int value)
{
std::cout << "new elem: " << value << std::endl;
children_.emplace_back(std::make_unique<Element>(value, this));
return children_.back().get();
}
bool moveChildren2Parent()
{
if (isRoot()) return false;
for (auto& c : children_)
{
// children change parent
c->parent_ = parent_;
parent_->children_.emplace_back(std::move(c));
}
children_.clear();
return true;
}
bool removeChild(size_t idx)
{
if (children_.size() <= idx) return false;
children_.erase(children_.begin()+idx);
return true;
}
bool isRoot() { return parent_ == nullptr; }
private:
int value_;
Element* parent_;
std::vector<std::unique_ptr<Element> > children_;
};
int main()
{
auto root = std::make_shared<Element>(1);
Element* last_child = root->insertChild(2)->insertChild(3)->insertChild(4);
last_child->getParent()->insertChild(5);
std::cout << "numChildren: " << last_child->getParent()->numChildren() << std::endl;
last_child->getParent()->moveChildren2Parent();
std::cout << "numChildren: " << last_child->getParent()->numChildren() << std::endl;
last_child->getParent()->removeChild(0); // element with value 3 removed, it's children already transferred
std::cout << last_child->getValue() << std::endl;
std::cout << last_child->getParent()->getValue() << std::endl;
std::cout << last_child->getParent()->getParent()->getValue() << std::endl;
std::cout << last_child->getParent()->getParent()->isRoot() << std::endl;
return 0;
}
It is just one of many possibilities, particular implementation choice always depends on the system requirements.

Answer 3

You have several problems with your code there. The most glaring one I can see is that you are freely converting between int pairs and elements. Classes provide a way to strongly type our code, if int, int is mean to represent an Element, make it an Element!
The reason you have to declare a default constructor is because you have already declared a constructor. The compiler will only generate a default one for you if you havnt already declared one.
To make the compiler explcitly generate one for you use default. Like this:
Element() = default;
To fix your weak typing issues you should use Element for m_parent and when adding an item to the Tree, if you need to do stuff like setting values of the parent then do that to the item you are passed to add. Like this
...
private:
Element m_parent;
...
void addElement(const Element& parent, int value)
{
Element elem = Element(value, parent);
m_elements.insert(std::pair<int,Element>(value,elem));
}
...
You also probably want to use a different container than std::map. If you want to have a concept of 'elements' then I would use std::set, store the element value or key as a member and overload the < operator (to allow sorting) to return the operation on the values/keys. std::set would allow you to search the tree (using a lambda with find_if) for keys or values as well as anything else (like parent matching).
This use of storing the parent as another Element also enables you to iterate back up the tree if you wanted too (independent of your container).