如何在 python 中使用 BFS 创建树？

Question

So I have a flattened tree in JSON like this, as array of objects:

[{
    aid: "id3",
    data: ["id1", "id2"]
},

{
    aid: "id1",
    data: ["id3", "id2"]
},

{
    aid: "id2",
    nested_data: {aid: "id4", atype: "nested", data: ["id1", "id3"]},
    data: []
}]

I want to gather that tree and resolve ids into data with recursion loops into something like this (say we start from "id3" ):

{
   "aid":"id3",
   "payload":"1",
   "data":[
      {
         "id1":{
            "aid":"id1",
            "data":[
               {
                  "id3":null
               },
               {
                  "id2":null
               }
            ]
         }
      },
      {
         "id2":{
            "aid":"id2",
            "nested_data":{
               "aid":"id4",
               "atype":"nested",
               "data":[
                  {
                     "id1":null
                  },
                  {
                     "id3":null
                  }
               ]
            },
            "data":[
               
            ]
         }
      }
   ]
}

So that we would get breadth-first search and resolve some field into "value": "object with that field" on first entrance and "value": Null

How to do such a thing in python 3?

Answer 1

Apart from all the problems that your structure has in terms of syntax (identifiers must be within quotes, etc.), the code below will provide you with the requested answer.

But you should carefully think about what you are doing, and have the following into account:

• Using the relations expressed in the flat structure that you provide will mean that you will have an endless recursion since you have items that include other items that in turn include the first ones (like id3 including id1 , which in turn include id3 . So, you have to define stop criteria, or be sure that this does not occur in your flat structure.
• Your initial flat structure is better to be in the form of a dictionary, instead of a list of pairs {id, data}. That is why the first thing the code below does is to transform this.
• Your final, desired structure contains a lot of redundancies in terms of information contained. Consider simplifying it.
• Finally, you mentioned nothing about the "nested_data" nodes, and how they should be treated. I simply assumed that in case that exist, further expansion is required.

Please, consider trying to provide a bit of context in your questions, some real data examples (I believe the data provided is not real data, therefore the inconsistencies and redundancies), and try yourself and provide your efforts; that's the only way to learn.

from pprint import pprint

def reformat_flat_info(flat):
    reformatted = {}
    for o in flat:
        key = o["aid"]
        del o["aid"]
        reformatted[key] = o
    return reformatted

def expand_data(aid, flat, lvl=0):
    obj = flat[aid]
    if obj is None: return {aid: obj}

    obj.update({"aid": aid})
    if lvl > 1:
        return {aid: None}

    for nid,id in enumerate(obj["data"]):
        obj["data"][nid] = expand_data(id, flat, lvl=lvl+1)

    if "nested_data" in obj:
        for nid,id in enumerate(obj["nested_data"]["data"]):
            obj["nested_data"]["data"][nid] = expand_data(id, flat, lvl=lvl+1)

    return {aid: obj}

# Provide the flat information structure
flat_info = [
    {
        "aid": "id3",
        "data": ["id1", "id2"]
    }, {
        "aid": "id1",
        "data": ["id3", "id2"]
    }, {
        "aid": "id2",
        "nested_data": {"aid": "id4", "atype": "nested", "data": ["id1", "id3"]},
        "data": []
    }
]
pprint(flat_info)
print('-'*80)

# Reformat the flat information structure
new_flat_info = reformat_flat_info(flat=flat_info)
pprint(new_flat_info)
print('-'*80)

# Generate the result
starting_id = "id3"
result = expand_data(aid=starting_id, flat=new_flat_info)
pprint(result)