How can I determine a specific level in a parent/child-array? - php

Question

I am looping over an array of groups, each element containing a parent id.
$currentparent = $group['grpId']; //$group is the current element in a loop wrapped around this piece of code
$currentlevel = 0;
foreach($groups as $grp)
{
$parent = $grp['grpParentId'];
if($parent != $currentparent && $currentlevel != 6)
{
//adding layer
$currentlevel++;
//changing parent
$currentparent = $grp['grpParentId'];
}
if($currentlevel == 6)
{
//call a special function
}
else
{
//call the regular function
}
}
This works fine on a array like this:
group
-group
--group
---group
----group
----- group <- the only group on the 5th layer
but not with an array which has multiple groups on the 5th level:
group
-group
--group
--group
---group
----group
-----group <- 5th layer
----group
-----group <- 5th layer too, but diff parent
How can I resolve this to get the special function called, even when there are multiple groups with multiple parents on the fifth level in the array?
I hope that I formulated my question clear enough.

Answer 1

Try iterating trough the the groups always searching for groups whose level can be determinated by its parent level. Something like this:
// example input
$groups = array(
array('grpParentId' => 0, 'grpId' => 1, ),
array('grpParentId' => 1, 'grpId' => 2, ),
array('grpParentId' => 2, 'grpId' => 3, ),
array('grpParentId' => 3, 'grpId' => 4, ),
array('grpParentId' => 4, 'grpId' => 5, ),
array('grpParentId' => 5, 'grpId' => 6, ),
array('grpParentId' => 6, 'grpId' => 7, ),
array('grpParentId' => 5, 'grpId' => 8, ),
array('grpParentId' => 8, 'grpId' => 9, ),
);
shuffle($groups); // just for testing the logic does in fact tolerate randomly ordered input
$rootId = 1; // set to the rootnode's id
$grouplevels = array();
// find the rootnode first
foreach($groups as $i => $grp) {
if ($rootId == $grp['grpId']) {
$grouplevels[$rootId] = 1;
unset($groups[$i]);
break;
}
}
// figure out childgroup levels
do {
$old_count = count($groups);
foreach($groups as $i => $grp) {
if (in_array($grp['grpParentId'], array_keys($grouplevels))) {
// the current node's parent's level was determinated previously, we can tell this group's level as well
$grouplevels[$grp['grpId']] = $level = $grouplevels[$grp['grpParentId']]+1;
if ($level == 6) {
print $grp['grpId']."\n";
}
// remove from the "we dont know yet" list
unset($groups[$i]);
}
}
} while (count($groups) < $old_count); // run while we can sort out at least one group's level in the current iteration
// handle the case when not every group's level could been determinated!
if (!empty($groups)) {
print "inconsitency ahead!";
}

Answer 2

It can be solved by using a recursive pattern. The following code should do the trick. It can probably be optimized.
$currentparent = $group['grpId']; //$group is the current element in a loop wrapped around
$this piece of code
$currentlevel = 0;
// Initialize
foreach($groups as $grp)
{
$grp['children'] = array();
}
foreach($groups as $grp)
{
$parent = $grp['grpParentId'];
$parent['children'][] = $grp;
}
foreach($groups as $grp)
{
if(empty($parent['children'])) $root = $grp; // Alternatively check if parent is null or something.
}
function recursive_count($root, $lvl = 0)
{
if($currentlevel == 6)
{
//call a special function
}
else
{
//call the regular function
}
foreach($root['children'] as $children)
{
recursive_count($children, $lvl++);
}
}
recursive_count($root);
Update: If memory consumption is a problem references can be used when adding a group to the children array.
Update II: Even though the algorithm has 4 foreach and a recursive structure the running time is still O(n) where n is the size of the graph.