Placing a user in a binary tree - php

Question

How can I find where to place users in my binary tree? considering the following binary tree:
1
/ \
2 3
/ \ / \
4 5 6 7
/ \ / \
8 9 10 11
How can I build a function to return where the next user should be placed?
The rule here is that a user must be placed up as high as possible in the tree under their sponsor with each node getting them evenly. So for example, for anyone coming in with 1 as their sponsor: the next user should go to 6, the one after to 7, then to 6, then to 7, then to 8.
If someone had a sponsor of 5, they would go under 10. Sponsor of 2, they would go under 8, etc.
I've been stuck for hours trying to figure this out, and built a recursive function but it would just go down the left side and land on 8 first (as it checks 1, then 2, then 4, then 8)
My model for the tree is pretty basic (if relevant), its a table with a self-relationship like so:
id | user_id | parent_id
So each user can only have 2 children (2 entries with their id as a parent_id)

Answer 1

Typically when you do recursion, you end up with exactly what you got, you fly down one side (in this case the leftmost) checking everything as you go and then end up finding something way down at the bottom of the tree.
What you want to do is use a First In First Out ("FIFO") stack. You start out by adding your tree to the stack and while there is anything on the stack and you still haven't found space, you loop. Each loop you get the first item off the stack and loop again to check each of it's children for space. If you find space, you set the child aside, if you didn't find space, you add the child to the end of the stack so we check the child's children on a later iteration. You keep doing this until you find some space. After checking all of the children nodes, if any space was found you compare the nodes set aside to see which has the most free space and that is your target. This lets you search horizontally by pulling stuff off the start of the stack and adding new things to the end. You end up checking each neighbor before the children.
Here is a sample that will return a reference to the first open node found:
<?php
$tree = [
1 => [
2 => [
4 => [
8 => [],
9 => [],
],
5 => [
10 => [],
11 => [],
],
],
3 => [
6 => [],
7 => [],
],
]
];
function &findNextLocation(&$tree, $maxChildren=2){
//shortcut, check the root tree first
if(count($tree) < $maxChildren){
return $tree;
}
//fifo stack, start with the whole tree.
//we use a FIFO stack here so that we can check all nodes horizontally
//before traversing down another level. This stores all the child nodes
//we still need to search.
$stack = array(&$tree);
//potential place with space
$out = null;
//go through and check everything
//loop while there is something on the stack and we haven't
//found space yet ($out is null).
//we check $out here so that we stop as soon as somewhere with
//space is found and assigned.
while(is_null($out) && !empty($stack)){
//get the first node from the tree
$branch = &$stack[0];
array_shift($stack);
//loop over every node at this branch and look for space
foreach($branch as $id=>&$node){
//if there is space, assign it to our output variable
if(count($node) < $maxChildren){
//check the number of open spaces compared to our out spaces
if(is_null($out) || count($out) > count($node)){
//better spot, assign this node
$out = &$node;
//if anyone has zero children, we can't find less than that so break
if(count($out) == 0){
break;
}
}
} else {
//space not found here, add to our stack so we check the children
$stack[] = &$node;
}
}
}
//not found
return $out;
}
print_r($tree);
//loop a few more times starting at our next number
for($i=12; $i<=20; $i++){
//get a reference to the open node
$node = &findNextLocation($tree);
//add this node as a child
$node[$i] = [];
//remove reference to the found node to prevent errors.
unset($node);
}
print_r($tree);
You can see a demo here: https://3v4l.org/X3BX4
The way you are describing this, it sounds like it is in an SQL table. You can use the above to find a position and insert a new value to an existing tree. Or if you add another column to the table that is depth meaning the distance from the root node, you can do it all in a query. The depth can't easily be calculated because it would require recursion which isn't really available with a procedure or user function. However, it is easy to update your current records by just parent depth+1. With a depth column, you can do something like this:
SELECT *
FROM tree_table as tt
WHERE
#where there is space (less than 2 children)
(SELECT COUNT(*)
FROM tree_table
WHERE parent_id=tt.id) < 2
ORDER BY
#distance from top of tree
depth,
#by free space
(SELECT COUNT(*)
FROM tree_table
WHERE parent_id=tt.id),
#leftmost
id
Demo here: http://sqlfiddle.com/#!9/5f6bfc/5