Python中最简单的树数据结构，可以在两个方向上轻松遍历

Question

I would need the simplest possible implementation for a data structure, that can be traversed in both parent->children and children->parent direction; so ideally the child should hold a reference to the parent as well.

Was thinking about a dictionary, where the children would simply hold a reference to their parent, similar to this:

# define the root node
a = {'name': 'trunk', 'value': 0, 'parent': None, 'children': []}
# add child
a['children'].append({'name': 'branch-1', 'value': 1,
                      'parent': a, 'children': []})
# and so on...

Is this safe to do? (Circular reference might impact garbage collection?) Does it make sense to do this? What would be simpler?

Answer 1

A simple Tree (Node) class, that can be traversed both ways:

class Tree(object):
    def __init__(self, data, children=None, parent=None):
        self.data = data
        self.children = children or []
        self.parent = parent

    def add_child(self, data):
        new_child = Tree(data, parent=self)
        self.children.append(new_child)
        return new_child

    def is_root(self):
        return self.parent is None

    def is_leaf(self):
        return not self.children

    def __str__(self):
        if self.is_leaf():
            return str(self.data)
        return '{data} [{children}]'.format(data=self.data, children=', '.join(map(str, self.children)))

> t = Tree('foo')
> bar = t.add_child('bar')
> baz = t.add_child('baz')
> print(t)
'foo [bar, baz]'

> print(bar.parent)
'foo [bar, baz]'

Answer 2

You would make a Node class.

The basic structure would look something like this, though honestly you could probably do it with dicts too. Just personally feel classes are cleaner looking.

class Node(object):
    def __init__(self):
        self.parent = None # Single object
        self.child = []  # Array of objects
        self.name = None
        self.data = None 

The rest depends on your needs. Some functions you may want built into your class (or if you use hashes, build out as methods in your script)

• Update: which takes a specific node and updates its values/name/what have you
• Delete: which takes a specific node and removes it from the tree. If you do this make sure to connect the deleted nodes children to the
  deleted nodes parent.
• Insert: which takes a specific point in the tree and adds a new node into it. This should update the parent and children around the node.
• Update children: appends children to node.child array. Should be called from update parent as the two processes are self referential.
• Update parent: Deletes self from parent.child array. Adds self to new_parent.child array.

If you want to easily reference specific parts of a node, you can make a hash_map as a sort of table of contents

node_tree_map = {}
node_tree_map[node.name] = node 
# node_tree_map['name'] would allow you quick access to bob's
# parent/children/value 
# just by knowing the name but without having to traverse 
# the whole tree to find it 

The above will allow you to easily dive into specific nodes if necessary.

Btw, removing a node from being referenced in the tree or hash map would make garbage collection a non issue.