python 中的 n 元树插入算法

Question

I'm trying to create sort of a nested round robin structure/tree where each child has N items. I believe this is what a n-ary tree is (the closest thing I could find for what I'm after) but I was not able to find a good python implementation and am trying to see if I can get help doing this right

So for example a tree of N=3 , given an initial root {"key": 1, "children": []} adding a new keys should result in this type of structure where each parent has max 3 children.

Image of how it should look

I'm definitely doing this in a very odd way and this is why I need guidance in either correcting my code or using a diff method entirely.

Here's my approach:

For a given N the max number of items for a given height follow this equation (where the root node is h=1)

N = 3
max_items = lambda n, h: int(n**(h-1) + n**h + n**(h-2))
height_map = {i: max_items(N, i) for i in range(1, 10)} # just pre compute first 10 levels for testing

# to get which index of the parent height the new item will go to, use
# here, when inserting 8 [self.count=7 -> count+1=8], the idx should equal 1 implying it should go under "3"
idx = ((self.count+1) - height_map[height-1] - 1) // self.N**(height-2)

class Tree:
    def __init__(self, N, tree):
        self.N = N
        self.count = 1
        self.tree = tree

    def add(self, item, tree=None, height=1):
        max_items = lambda n, h: int(n**(h-1) + n**h + n**(h-2))
        height_map = {i: max_items(self.N, i) for i in range(1, 10)}

        tree = tree if tree else self.tree
        if len(tree["children"]) >= self.N and height > 1:
            if (self.count+1) <= height_map[height]:
                idx = ((self.count+1) - height_map[height-1] - 1) // self.N**(height-2)
            child = tree["children"][idx]
            return self.add(item, child, height+1)
        elif len(tree["children"]) >= self.N and height == 1:
            return self.add(item, tree["children"][0], height+1)
        else:
            self.count += 1
            tree["children"].append({"key": item, "children": []})
        return tree

t = Tree(3, {"key": 1, "children": []})
for i in range (2, 8):
    t.add(i)
print(t.tree)

This following code works great up to inserting 7 but there's some error in my logic that does not let you properly add 8 and manage the next depths. I don't think I'm passing the root tree correctly as I get to the lower height but can't figure out how to fix this.

{'children': [{'children': [{'children': [], 'key': 5},
                            {'children': [], 'key': 6},
                            {'children': [], 'key': 7}],
               'key': 2},
              {'children': [], 'key': 3},
              {'children': [], 'key': 4}],
 'key': 1}

I'm not tied to the order the items are inserted either and only care about this structure but can't seem to make sense of it.

Answer 1

Here is a simpler way of representing a 3-ary tree:

If you have the structure

               a                               0           
        /      |      \                 /      |      \    
       b       c       d               1       2       3   
      /|\     /|\     /|\             /|\     /|\     /|\  
     e f g   h i j   k l m           4 5 6   7 8 9   10 11 12 
    /|                              /|                     
   n o                             13 14                     

Represent it as a list:

[a, b, c, d, e, f, g, h, i, j,  k,  l,  m,  n,  o]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]

(The second list is just the indices of the nodes)

For a given node at index i , it's children are at indices 3*i + 1 , 3*i + 2 and 3*i + 3 . For example, the children of node c (index 2 ) are h , i , and j at indices 7 , 8 , 9 respectively.

For a given node (except the root node) at index i , the node's parent is at index (i - 1) / 3 . For example, parent of node i (index 8 ) is 2 .

To add a new node, simply append to this list, and it will become the child of a node.

The tree will be complete (ie filled in at every possible level), except possibly for the last level which is filled-in from left to right.

Note that this tree structure is quite similar to a heap but with 3 children instead of 2.