具有PHP關聯陣列的建築遞歸樹結構

要將扁平數據構建成遞歸樹結構，需使用關聯數組高效映射節點；1. 遍歷數據創建以ID為鍵的關聯數組，每個節點初始化空children；2. 再次遍歷，通過parent_id將當前節點引用加入父節點的children數組中，根節點放入tree數組；3. 最終得到嵌套樹結構，該方法時間複雜度接近O(n)，優於遞歸方案，適用於分類、評論等層級場景。

When working with hierarchical data in PHP—like categories, comments, or organizational structures—you often need to build recursive tree structures from flat data. Associative arrays in PHP are perfect for this task because they allow you to map IDs to nodes and efficiently nest children under their parents.

Here's how to convert a flat list (eg, from a database) into a nested tree using recursive logic and associative arrays.

Understanding the Input Data

Assume you have a flat array of items, each with an id , parent_id , and some data :

 $flatData = [
    ['id' => 1, 'parent_id' => null, 'name' => 'Electronics'],
    ['id' => 2, 'parent_id' => 1, 'name' => 'Mobile Phones'],
    ['id' => 3, 'parent_id' => 1, 'name' => 'Laptops'],
    ['id' => 4, 'parent_id' => 2, 'name' => 'Smartphones'],
    ['id' => 5, 'parent_id' => 4, 'name' => 'Android'],
    ['id' => 6, 'parent_id' => 4, 'name' => 'iOS'],
];

Our goal is to turn this into a nested tree where each node contains its children.

Step 1: Map Items by ID

First, build an associative array where each id points to its full data, and add an empty children array to each:

 $items = [];
foreach ($flatData as $item) {
    $item['children'] = [];
    $items[$item['id']] = $item;
}

This gives us fast access to any node by ID.

Step 2: Attach Children to Parents

Loop through the items and attach each item to its parent using parent_id . If parent_id exists, push the item into the parent's children array. Root items (with null parent) will remain top-level.

 $tree = [];

foreach ($items as $id => &$item) {
    $parentId = $item['parent_id'];
    if ($parentId === null) {
        $tree[] = &$item;
    } else {
        if (isset($items[$parentId])) {
            $items[$parentId]['children'][] = &$item;
        }
    }
}
unset($item); // break reference

We use references ( & ) to ensure changes propagate correctly.

Step 3: Resulting Tree Structure

Now $tree contains the root nodes, each with recursively nested children:

 print_r($tree);

Output (simplified):

 Array
(
    [0] => Array
        (
            [id] => 1
            [parent_id] => 
            [name] => Electronics
            [children] => Array
                (
                    [0] => Array
                        (
                            [id] => 2
                            [parent_id] => 1
                            [name] => Mobile Phones
                            [children] => Array
                                (
                                    [0] => Array
                                        (
                                            [id] => 4
                                            [parent_id] => 2
                                            [name] => Smartphones
                                            [children] => Array
                                                (
                                                    [0] => Array
                                                        (
                                                            [id] => 5
                                                            [parent_id] => 4
                                                            [name] => Android
                                                            [children] => Array()
                                                        )
                                                    [1] => Array
                                                        (
                                                            [id] => 6
                                                            [parent_id] => 4
                                                            [name] => iOS
                                                            [children] => Array()
                                                        )
                                                )
                                        )
                                )
                        )
                    [1] => Array
                        (
                            [id] => 3
                            [parent_id] => 1
                            [name] => Laptops
                            [children] => Array()
                        )
                )
        )
)

Optional: Recursive Function to Build Tree (Alternative)

You can also use recursion to build the tree, though it's less efficient for large datasets:

 function buildTree($items, $parentId = null) {
    $branch = [];
    foreach ($items as $item) {
        if ($item['parent_id'] == $parentId) {
            $children = buildTree($items, $item['id']);
            if ($children) {
                $item['children'] = $children;
            }
            $branch[] = $item;
        }
    }
    return $branch;
}

$tree = buildTree($flatData);

This version avoids references but has O(n²) time complexity in the worst case. The associative array mapping method is more scalable.

Key Points

• Use associative arrays to map id => node for O(1) lookups.
• Build the tree iteratively by attaching children to parents via references.
• Avoid repeated scanning by leveraging parent-child relationships.
• Be cautious with references in PHP—always unset after looping by reference.

This pattern is widely used in CMS systems, e-commerce categories, comment threads, and file directory structures.

Basically, it's not complex—but using associative arrays smartly makes it fast and clean.

以上是具有PHP關聯陣列的建築遞歸樹結構的詳細內容。更多資訊請關注PHP中文網其他相關文章！