Рекурсивно сортировать массив по уровням

Question

Я работал над сайтом, который использует двоичную систему MLM.

Иллюстрация здесь

Итак, у меня есть две таблицы в базе данных, пользователи и отношения. У пользователей есть столбцы ID и персональных данных. Отношения имеют 4 столбца: ID, parentID, childID, поз. Где pos либо слева, либо справа.

Я успешно написал функцию, которая рекурсивно перечисляет всех потомков данного pid (parentID). Однако мне нужно отсортировать его по уровням (для отображения и в целях расчета).

У меня есть массив детей с идентификатором пользователя = 1:

Array
(
    [0] => Array
        (
            [id] => 2
            [parentID] => 1
            [pos] => l
        )

    [1] => Array
        (
            [id] => 4
            [parentID] => 2
            [pos] => l
        )

    [2] => Array
        (
            [id] => 8
            [parentID] => 4
            [pos] => l
        )

    [3] => Array
        (
            [id] => 5
            [parentID] => 2
            [pos] => p
        )

    [4] => Array
        (
            [id] => 3
            [parentID] => 1
            [pos] => p
        )

    [5] => Array
        (
            [id] => 6
            [parentID] => 3
            [pos] => l
        )

    [6] => Array
        (
            [id] => 7
            [parentID] => 3
            [pos] => p
        )

)

Теперь у меня есть функция с именем get_levels, которая возвращает многомерный массив, который должен выглядеть следующим образом:

Array
(
    [0] => Array
        (
            [0] => Array
                (
                    [id] => 2
                    [parentID] => 1
                    [pos] => l
                )

            [1] => Array
                (
                    [id] => 3
                    [parentID] => 1
                    [pos] => p
                )

        )
   [1] => Array
        (
            [0] => Array
                (
                    [id] => 4
                    [parentID] => 2
                    [pos] => l
                )

            [1] => Array
                (
                    [id] => 5
                    [parentID] => 2
                    [pos] => p
                )
            [2] => Array
                (
                    [id] => 6
                    [parentID] => 3
                    [pos] => l
                )

            [3] => Array
                (
                    [id] => 7
                    [parentID] => 3
                    [pos] => p
                )

        )
  ETC.

) 

Вот функция:

 function get_levels($pid,$level, $level_id){
       $children = children_array($pid,1);
       if (sizeof($children) > 0):
          foreach ($children as $child):
             if ($child["parentID"] == $pid):


                get_levels($child["id"], $level, $level_id+1);
                $level[$level_id][] = $child;           


        endif;  


         endforeach;
      endif;
      return $level;
 }

функция children_array ($ pid, $ deep) возвращает потомков ... для $ deep = 1 возвращает непосредственных потомков (0 или 1 или 2), для $ deep = 0 возвращает всех потомков

Кто-нибудь может мне помочь с этой функцией? Я думаю, что функция работает, однако я не знаю, как рекурсивно использовать и добавлять в массив.

Answer 1

Похоже, вы используете структуру данных в неправильном контексте. Это двоичное дерево, но оно представлено в виде многоуровневого массива, который вкратце не определяет его границы и правила использования.

При использовании дерева я бы использовал что-то вроде класса Node, у которого есть два потомка, левый и правый. Итерация по дереву была бы легкой задачей, вставка / удаление / редактирование в нем легко выполняются в зависимости от того, какой набор правил вы хотите соблюдать. При хранении дерева я бы использовал какой-то список Ahnentafel , который можно легко сделать в реляционной базе данных.

Я никоим образом не смешивал бы итерационные процессы и процессы хранения, потому что, если я изменю правила хранения, мне, возможно, также придется изменить правила итерации и наоборот.