C++ Run time efficiency - c++

Question

I'm creating a hex board out of nodes.Everything I have in this bit of code works perfectly. My problem is the item that is starred slows down this loop from taking ~1 second to about 1 minute. It isn't the number of items in the vector because if i remove them all except the last one it still takes ~1 minute. either way there are no run time errors.
for (x = 0; x < size; ++x)
{
for (y = 0; y < size; ++y)
{
this->nodes[x][y].neighbors = std::vector<node>(6);
if ((x == 0) && (y == 0))
{
this->nodes[x][y].neighbors =
{
nodes[x + 1][y],
this->nodes[x][y + 1]
};
}
else if ((x == 0) && (y == max))
{
this->nodes[x][y].neighbors =
{
this->nodes[x + 1][y],
this->nodes[x][y - 1],
this->nodes[x + 1][y - 1]
};
}
else if ((x == max) && (y == 0))
{
this->nodes[x][y].neighbors =
{
this->nodes[x - 1][y],
this->nodes[x][y + 1],
this->nodes[x - 1][y + 1]
};
}
else if ((x == max) && (y == max))
{
this->nodes[x][y].neighbors =
{
this->nodes[x - 1][y],
this->nodes[x][y - 1]
};
}
else if (y == 0 && (x != 0 && x != max))
{
this->nodes[x][y].neighbors =
{
this->nodes[x - 1][y],
this->nodes[x + 1][y],
this->nodes[x - 1][y + 1],
this->nodes[x][y + 1]
};
}
else if (y == max && (x != 0 && x != max))
{
this->nodes[x][y].neighbors =
{
this->nodes[x - 1][y],
this->nodes[x + 1][y],
this->nodes[x - 1][y - 1],
this->nodes[x][y - 1]
};
}
else if (x == 0 && (y != 0 && y != max))
{
this->nodes[x][y].neighbors =
{
this->nodes[x][y - 1],
this->nodes[x][y + 1],
this->nodes[x + 1][y],
this->nodes[x + 1][y - 1]
};
}
else if (x == max && (y != 0 && y != max))
{
this->nodes[x][y].neighbors =
{
this->nodes[x][y - 1],
this->nodes[x][y + 1],
this->nodes[x - 1][y - 1],
this->nodes[x - 1][y]
};
}
else
{
this->nodes[x][y].neighbors =
{
this->nodes[x + 1][y],
this->nodes[x - 1][y],
this->nodes[x][y - 1],
this->nodes[x + 1][y - 1],
this->nodes[x][y + 1],
this->nodes[x - 1][y + 1]
};
}
}
}

Answer 1

Given the idea is to track neighbours that you know have been pre-created, you probably only want to keep a reference or pointer to them; you should not copy the nodes by value as you currently do.
You could use vector<reference_wrapper<node>> or vector<node*>, with respective initialisation like this:
nodes[x][y].neighbors = { ref(nodes[a][b]), ref(nodes[c][d])... };
nodes[x][y].neighbors = { &nodes[a][b], &nodes[c][d], ... };
With pointers, when you access neighbors[n] you'll obviously need to dereference the pointer too.
Regarding why it was so slow... the copying by value meant copying nodes into neighbours was copying all those neighbouring node's neighbours, and their neighbours, ad nauseum... getting slower and slower as the number of nodes with long neighbour hierarchies increased.

Answer 2

The slowness comes from 2 things:
The last else clause gets hit the most.
The last clause copies more node items than the rest
A few suggestions:
Use pointers or indexes not node objects for neighbors. Less copying.
It will be faster to have a fixed size array for neighbors. Will improve locality and memory significantly. You'll have to add a neighbor count for that array.