How do i use doubly(**) pointer in C++ for general tree data structure?

Question

I have a structure s :

struct s{
   int x;
  /********************************************************************
   *  NoOfchild doesn't represent maximum no of children for node s . 
   *  This represent no of children node s have at any given instance . 
   *********************************************************************/      
   int NoOfChild; 
   s  **child;
}

I would like to use ** to declare array of pointers dynamically . Node s is added one by one to array .There is any way to achieve this. This tree is going to use for FpGrowth Algorithm.

                                         *(0) 
                                           |
          _____________________________________________________________
          |                                |                          | 
       [* (1)                             *(2)                      *(3)]
          |                                |                          |
_______________                    _________________        __________________________
|    |    |   |                   |        |       |        |    |    |     |    |   |
[*   *    *   *]                  [*       *       *]      [*    *    *     *    *   *]

** represent Node s . I don't want to declare all children of a node at the same time i.e. I would like to add child node one by one when ever it's required . e.g. o is added as root then node 1 is added as child of root if it requires then node 2 is added and so on .[* * * * ] represents children of a node x .

Edit:
People are assuming NoOfChild as maximum no of a child for a given node that's not true ,Here NoOfChild represents how many children a node have at given instance , it may vary according to requirement or time to time .
Explanation :
Initially node 0 is Initialized so it has zero(0) child .
then node 1 is added as child of node 0 so o->NoOfChild = 1 and 1 ->NoOfChild = 0 ;
then node [*] is added as child of node 1 so 0->NoOfChild = 1 and 1 ->NoOfChild = 1 ;
then 2 is added as child of node 0 so 0->NoOfChild = 2 and 1 ->NoOfChild = 1 ;
and so on .

Edit:
Finally used vector<s*> child .

Answer 1

For general tree data structure you can use :-

 struct tree{
 int element;
 struct tree *firstchild;
 struct tree *nextsibling;
 };

element contains the data to be inserted at the node.

FirstChild contains the firstchild of the node.

nextsibling contains the other child of the same parent node. Example :-

   A

 B  C  D

EF  G     H

then A->firstchild = B; B->nextsibling=C; C->nextsibling=D; B->firstchild=E; E->nextsibling=F; C->firstchild=g; D->firstchild=H;

Other values which are not specified can taken as NULL;

Answer 2

The first answer is: you don't. Use a container class like everyone in the comments indicated.

The second answer is: dynamic allocation:

void addNewChild(s *into, s* new_child)
{
   s **tmp_s = new s*[into->NoOfChild+1];    ///< will throw if allocation fails

   for(int i=0; i<into->NoOfChild; i++) tmps[i] = into->child[i];  ///< use a memcpy instead
   tmps[into->NoOfChild++] = new_child;

   s **del_s = into->child;
   into->child = tmp_s;
   delete[] del_s;
}

And finally: don't do this. Use std::vector<s> or std::vector<s*> depending on how many parents a child can have.

Answer 3

A plain c version:

struct node
{
    int key;
    int noOfChild;
    struct node** childrenArray;
};

struct node* newNode(int key, int noOfChild)
{
    int i;
    struct node* node = (struct node*) malloc(sizeof(struct node));
    node->key = key;
    node->noOfChild = noOfChild;
    node->childrenArray = (struct node**) malloc(noOfChild * sizeof(struct node*));
    for(i=0;i<noOfChild;i++)
    {
        node->childrenArray[i] = NULL;
    }
    return(node);
}

Answer 4

Since you tagged c++:

#include <vector>
#include <memory>
#include <algorithm>
#include <iostream>

template <class ValueType>
class VariadicTree
{
public:
    VariadicTree(const ValueType& value) : m_value(value), m_size(0)
    {
    }

    VariadicTree<ValueType>& addNode(const ValueType& value)
    {
        m_children.emplace_back(new VariadicTree<ValueType>(value));
        ++m_size;
        return *m_children.back();
    }

    bool leaf()
    {
        return std::all_of(m_children.begin(), m_children.end(),
                           [&](const std::unique_ptr<VariadicTree<ValueType>>& ptr)
                              {return ptr == nullptr;});
    }

    size_t size()
    {
        return m_size;
    }

    const ValueType& value()
    {
        return m_value;
    }

private:
    size_t m_size;
    const ValueType& m_value;
    std::vector<std::unique_ptr<VariadicTree<ValueType>>> m_children;
};

int main()
{
    VariadicTree<int> root(5);
    auto& c1 = root.addNode(4);
    auto& c2 = root.addNode(6);
    auto& c3 = root.addNode(2);

    auto& c11 = c1.addNode(2);

    std::cout << root.leaf() << "\n";
    std::cout << c11.leaf() << "\n";
    std::cout << root.size() << "\n";
    std::cout << c1.size() << "\n";
    std::cout << c11.size() << "\n";

    return 0;
}

Ownership can probably be handled more elegantly but this should do for demonstration purposes.

Answer 5

I solved using

struct s{
   int x;
   vector<s*> child ;
}

This helps more , since all pointers/references is managed by STL .