How Can I Efficiently Parse a Flat Table into a Nested Tree Structure?

The flat watch is efficiently analyzed as a tree structure

Introduction

The flat surface of the tree -shaped hierarchical structure is highly transformed into an nested structure, which can be implemented in multiple methods. This article discusses a minimalist solution that uses the basic data structure and considers the alternative database storage method for optimizing the tree -shaped representation.

The minimalist method of parsing

Assume that a table contains the following data:

This table is analyzed as a tree structure:

Id	Name	ParentId	Order
1	'Node 1'	0	10
2	'Node 1.1'	1	10
3	'Node 2'	0	20
4	'Node 1.1.1'	2	10
5	'Node 2.1'	3	10
6	'Node 1.2'	1	20

Create a dictionary:
1. Map the ID of each node to its corresponding data.
   Identification of the root node:
The root node is a node without Parentid.

2. Build a tree:

   Create a sub -node by recursively and add it to the corresponding parent node to build a tree.

3. For each non -root node, use its Parentid to find its parent node in the dictionary. Add the node as the child node of the parent node.

   • Sorting node:
   Sort the sub -nodes of each node according to the order of the child node.

4. The pseudo code of this method:

The alternative storage method of the tree structure in SQL

Closure table:

Another method of storing the tree structure in the relationship database is to use a closure table, which contains a separate table, which contains the ancestral node ID and the offspring node ID column. This allows easy query relationships.

<code>创建字典(table)
def 获取根节点():
    根节点 = []
    对于 id, 节点 in 字典.items():
        如果 节点['ParentId'] == 0:
            根节点.append(节点)
    返回 根节点

def 构建树(根节点):
    对于 根节点 in 根节点:
        子节点 = []
        对于 id, 节点 in 字典.items():
            如果 节点['ParentId'] == 根节点['Id']:
                子节点.append(节点)
        子节点.sort(key=lambda x: x['Order'])
        根节点['children'] = 子节点
        构建树(子节点)

def 打印树(根节点):
    对于 根节点 in 根节点:
        打印(根节点['Name'])
        如果 'children' in 根节点:
            打印树(根节点['children'])</code>

Inquiries using the closure table:

Embeds:

The nested set involves the location information of each node in the storage tree in a single table. This method allows efficient scope -based queries of nodes in a given level or sub -tree.

Conclusion Although the examples provided using flat tables are used as input, the proposed methods are very suitable for different data structures and storage methods. By using appropriate technology, you can efficiently analyze the tree -shaped hierarchical structure and ensure data integrity and easy access.

The above is the detailed content of How Can I Efficiently Parse a Flat Table into a Nested Tree Structure?. For more information, please follow other related articles on the PHP Chinese website!