This article details how to use PHP to convert flattened array data into a tree structure. With recursive algorithms, we can efficiently process arrays containing parent-child relationships and organize them into tree-like data structures that are easy to understand and manipulate. The article provides complete code examples and detailed explanations to help developers understand the principles and applications of recursion, thereby easily converting arrays to trees.

Understand tree structures and flattened arrays

Tree structure is a common way of organizing data. It simulates the tree structure in nature and consists of root nodes, child nodes and leaf nodes. Each node can have many child nodes, but only one parent node (except the root node).

Flattened arrays store data with hierarchical relationships in a one-dimensional array, and use specific fields (such as id and parent_id) to represent the parent-child relationship between nodes.

Converting flat arrays into tree structures makes it easier to display, navigate, and operate hierarchical data.

Recursive algorithm implements tree structure conversion

The following is an example code that uses PHP's recursive algorithm to convert a flattened array into a tree structure:

 <?php /**
 * Recursively build tree structure*
 * @param array $elements Flattened array * @param mixed $parentId Parent node ID, default is null
 * @return array tree structure array*/
function buildTree(array $elements, $parentId = null): array
{
    $branch = [];
    foreach ($elements as $element) {
        if ($element[&#39;parent_id&#39;] === $parentId) {
            $children = buildTree($elements, $element[&#39;id&#39;]);
            if ($children) {
                $element[&#39;children&#39;] = $children;
            }
            $branch[] = $element;
        }
    }

    return $branch;
}

// Sample data $array = [
    [&#39;id&#39; => 1, 'parent_id' => '-', 'name' => 'id1'],
    ['id' => 2, 'parent_id' => 1, 'name' => 'id2'],
    ['id' => 3, 'parent_id' => 1, 'name' => 'id3'],
    ['id' => 4, 'parent_id' => '-', 'name' => 'id4'],
    ['id' => 5, 'parent_id' => 2, 'name' => 'id5'],
    ['id' => 6, 'parent_id' => 3, 'name' => 'id6'],
    ['id' => 7, 'parent_id' => '-', 'name' => 'id7'],
    ['id' => 8, 'parent_id' => 3, 'name' => 'id8'],
    ['id' => 9, 'parent_id' => 4, 'name' => 'id9'],
    ['id' => 10, 'parent_id' => 9, 'name' => 'id10'],
];

//Initialize the tree structure $tree = [];
foreach ($array as $element) {
    // Find the root node (the node whose parent_id is '-')
    if ($element['parent_id'] === '-') {
        $tree[] = [
            'id' => $element['id'],
            'name' => $element['name'],
            'children' => buildTree($array, $element['id']),
        ];
    }
}

//Print the tree structure print_r($tree);

?>

Code explanation:

1. buildTree function: This is a recursive function used to build a tree structure.

   • It accepts two parameters: $elements (flattened array) and $parentId (parent node ID).
   • It iterates through the $elements array and finds the element whose parent_id is equal to $parentId.
   • For each element found, it calls the buildTree function recursively, looking for the element's child nodes.
   • If child nodes are found, they are added to the current element's children attribute.
   • Finally, it returns an array containing all child nodes.

2. Main program:

   • First, define a flattened array $array, which contains the node's id, parent_id and name attributes.
   • Then, initialize an empty array $tree to store the final tree structure.
   • Traverse the $array array and find the root node (the node whose parent_id is '-').
   • For each root node, call the buildTree function to build its subtree, and add the root node and its subtrees to the $tree array.
   • Finally, use the print_r function to print the $tree array to display the constructed tree structure.

Things to note

• Circular references: Make sure there are no circular references in the flattened array, otherwise the recursive function may loop infinitely.
• Performance: Recursive algorithms can impact performance when processing large data sets. Consider using iterative algorithms to optimize performance.
• Parent node ID: The code assumes that the parent_id of the root node is '-', which can be modified according to specific circumstances in actual applications.

Summarize

Through this article, you learned how to use PHP's recursive algorithm to convert a flattened array into a tree structure. Understanding the principles and applications of recursion can help you solve many similar problems, such as building menus, organizing file directories, etc. Remember, recursion is a powerful tool, but it needs to be used with caution to avoid infinite loops and performance issues.

The above is the detailed content of Convert PHP array to tree structure: Detailed explanation of recursive algorithm. For more information, please follow other related articles on the PHP Chinese website!