层级数据存储

要存储的数据如下图所示

要求：把下面的数据存储到 mysql 数据库中，并能把数据库中读取数据转换成原来的数据

data: [{
    
    
    label: '一级 1',
    children: [{
    
    
        label: '二级 1-1',
        children: [{
    
    
            label: '三级 1-1-1'
        }]
    }]
}, {
    
    
    label: '一级 2',
    children: [{
    
    
        label: '二级 2-1',
        children: [{
    
    
            label: '三级 2-1-1'
        }]
    }, {
    
    
        label: '二级 2-2',
        children: [{
    
    
            label: '三级 2-2-1'
        }]
    }]
}, {
    
    
    label: '一级 3',
    children: [{
    
    
        label: '二级 3-1',
        children: [{
    
    
            label: '三级 3-1-1'
        }]
    }, {
    
    
        label: '二级 3-2',
        children: [{
    
    
            label: '三级 3-2-1'
        }]
    }]
}]

数据表设计

很明显这可以用递归来做，只要设计一种方便递归处理的结构即可

create table layer(
	lid int primary key,
    label varchar(20) not null,
    nid int(11) not null
)

算法设计

为方便测试，这里使用列表来模拟从数据库获取的数据

data = [
    [1,'一级 1',0],[2,'二级 1-1',1],[3,'三级 1-1-1',2],
    [4,'一级 2',0],[5,'二级 2-1',4],[6,'三级 2-1-1',5],
    [7,'二级 2-2',4],[8,'三级 2-2-1',7],
    [9,'一级 3',0],[10,'二级 3-1',9],[11,'三级 3-1-1',10],
    [12,'二级 3-2',9],[13,'三级 3-2-1',12],
]

首先设计一个用来存储的数据结构，主要是把单链表改了一下

class LinkedNode:
    def __init__(self,lid,label,nid):
        self.lid = lid
        self.nid = nid
        self.node = {
    
    'label':label}
        self.next_node = None

核心算法：

1. 把数据处理成[LinkedNode(),...,LinkedNode()]

2. 获得所有nid等于此节点lid的节点

3. 从根LinkedNode中获得要添加子节点的节点，

   添加到获得的节点中，递归调用

# 把数据处理成[LinkedNode(),]这样的结构
def parseData(self,data):
    res = []
    for i in data:
        res.append(LinkedNode(i[0],i[1],i[2]))
    return res

# 获得所有nid等于lid的节点
def getEqualNode(self,lid):
    result = []
    for i in self.data:
        if i.nid == lid:
            result.append(i)
    return result

# 递归处理节点
def getNode(self,data):
    result = self.getEqualNode(data.lid)
    if len(result)>0:
        for j in result:     
            self.root.get(data.lid).add(j)
            self.getNode(j)

完整代码

class LinkedNode:
    def __init__(self,lid,label,nid):
        self.lid = lid
        self.nid = nid
        self.node = {
    
    'label':label}
        self.next_node = None

    def add(self,node):
        if not 'children' in list(self.node.keys()):
            self.node['children'] = [node]
        else:
            self.node['children'].append(node)
        self.next_node = node
        
    def get(self,lid):
        # 根据lid获取子节点
        root = self
        while root.next_node != None:
            root = root.next_node
            if root.lid == lid:
                return root
        return self
            

    def __repr__(self):
        return str(self.node)

class DataProcessing:
    def __init__(self,data):
        self.data = self.parseData(data)
        self.root = LinkedNode(0,'0标题',-1)
        self.start()

    # 把数据处理成[LinkedNode(),]这样的结构
    def parseData(self,data):
        res = []
        for i in data:
            res.append(LinkedNode(i[0],i[1],i[2]))
        return res
       
    # 获得所有rid等于lid的节点
    def getEqualNode(self,lid):
        result = []
        for i in self.data:
            if i.nid == lid:
                result.append(i)
        return result
    
    # 递归处理节点
    def getNode(self,data):
        result = self.getEqualNode(data.lid)
        if len(result)>0:
            for j in result:       
                self.root.get(data.lid).add(j)
                self.getNode(j)

    # 开始处理
    def start(self):
        self.getNode(self.root)

    # 获取结果
    def get_result(self):
        return self.root.node['children']

data = [
    [1,'一级 1',0],[2,'二级 1-1',1],[3,'三级 1-1-1',2],
    [4,'一级 2',0],[5,'二级 2-1',4],[6,'三级 2-1-1',5],
    [7,'二级 2-2',4],[8,'三级 2-2-1',7],
    [9,'一级 3',0],[10,'二级 3-1',9],[11,'三级 3-1-1',10],
    [12,'二级 3-2',9],[13,'三级 3-2-1',12],
]
data_processing = DataProcessing(data)
result = data_processing.get_result()
print(result)