记一次面试算法题

题目是这样的：

假设我们爬虫团队采集到了天猫的行业信息，例如：
industry_list = [
{
“parent_ind” : “女装”,
“name” : “连衣裙”
},
{
“name”: “女装”
},
{
“parent_ind” : “女装”,
“name” : “半身裙”
},
{
“parent_ind” : “女装”,
“name” : “A字裙”
},
{
“name”: “数码”
},
{
“parent_ind” : “数码”,
“name”: “电脑配件”
},
{
“parent_ind” : “电脑配件”,
“name”: “内存”
},
]
为了取用方便，我们希望可以将其转换为树状格式，例如：
{
“数码”: {
“电脑配件”: {
“内存” : {}
},
“女装” : {
“连衣裙”: {},
“半身裙”: {},
“A字裙”: {}
}
}实现一个方法完成这个转换def convert_format(data)

看到这个题，可以用比较简单的方法，就是设定好目标格式的字典，然后遍历，比较即可，时间复杂度也只有O(n)；但会有个问题，题目也没说，就是如果层级更深，比如在”内存“的下面还有一级分类，这样的死方法会失效。
如果想要不受层级限制呢？目前给的示例是3个层级，n个呢？我们可以考虑用树。

class ItemNode:
    def __init__(self, name, parent, child: dict): 
        """
        :param name: node name
        :param parent: node parent name,and root node's name is None
        :param child: dict,looks like that:{child_name:child_item_obj or{}}
        """
        self.name = name
    	self.parent = parent
        self.child = child

先构造树节点，然后从一个列表中构建树，时间复杂度O(n^2)，这里用到了一个队列作辅助：

from queue import Queue
def create_tree(node_list, root):
    q = Queue()
    q.put(root)
    while q.empty() is not True:
        r_node = q.get()
        for node in node_list:
            if node.parent == r_node.name:
                r_node.child.update({node.name: node})
        if r_node.child != {}:
            for v in r_node.child.values():
                if v != {}:
                    q.put(v)

现在已经构建好一课完整的树了，只需要从根节点向下递归遍历，则可把树转成字典的形式：

def tree2dict(input_root, d: dict):
    if input_root.child == {}:
        return
    for k, v in input_root.child.items():
        d[v.name] = {}
        tree2dict(v, d[v.name])

所以最终的函数应该是这样：

def convert_format(data: list):
    item_node_list = [ItemNode(item.get('name'), item.get('parent_ind') or 'root', {}) for item in data]
    root_node = ItemNode(name='root', parent=None, child={})
    create_tree(item_node_list, root_node)
    result_dict = {}
    tree2dict(root_node, result_dict)
    return result_dict

这样就完全实现了符合要求的函数，且可读性、扩展性较好。