You can do a depth first search. Just keep track of which items you've seen in a set. Then yield each one you haven't seen and yield from the result of recursive call:

def get_all_descendants(t, d, seen=None):
    if seen is None:
        seen = set([t])
    for item in d[t]:
        if item not in seen:
            seen.add(item)
            yield item
            yield from get_all_descendants(item, d, seen)

list(get_all_descendants('charges', d))

This will give you this list:

['mview',
 'status',
 'accounts',
 'nodate',
 'tainlog',
 'remfile',
 'retlog',
 'retfile',
 'bb',
 'payfile',
 'aa',
 'snaps',
 'raw',
 'pview',
 'balance']

The data preparation step is a little hideous, because your IDs are starting from one we need a blocker element None at position 0:

original = [(1, 'A', 0),
            (2, 'B', 1),
            (3, 'C', 1),
            (4, 'D', 2),
            (5, 'E', 2),
            (6, 'F', 3),
            (7, 'G', 2),
            (8, 'H', 6),
            (9, 'I', 4)]
ids,data,parents = zip(*original)
data =[None]+list(data)
parents = [None]+list(parents)

This code will work once you get your input data in the right format:

ids = range(1,10)
parents = [None,0,1,1,2,2,3,2,6,4]
data =[None,"A","B","C","D","E","F","G","H","I"]

def get_parents(node):
    if not parents[node]:
        return data[node]
    return get_parents(parents[node])+data[node]
for id in ids:
    print ".".join(list(get_parents(id)))
>>> 
A
A.B
A.C
A.B.D
A.B.E
A.C.F
A.B.G
A.C.F.H
A.B.D.I

However, I don't know why the new dictionary of my recursive function can only store those people that have no child.

def findSub(dict, parent, level, newDict):

    level += 1

    children = dict[parent][0]

    if (len(children) == 0):
    ^^^^^^^^^^^^^^^^^^^^^^^^
        info = [dict[parent][0], level]
   .....

This if checks if the element has no children. If it has children you recurse further, but you don't add the element before recursing further.

If you wanted to save even the parents (which in end will result in the whole subtree), you would do something like

def findSub(dict, parent, level, newDict):

    level += 1

    children = dict[parent][0]
    info = [dict[parent][0], level]
    newDict[parent] = info

    if (len(children) != 0):
        for child in children:
            findSub(dict, child, level, newDict)

    return newDict

Some terminology. We're doing a transitive closure over a forest (a data structure containing the roots of many trees). By denoting the structure as a forest, I'm assuming there are no cycles in the graph.

def transitive_closure(forest):
    def recurse(root, path):
        if root in forest and forest[root]:
            for x in forest[root]:
                path.append(root)
                recurse(x, path)
                path.pop()
        elif path:
            result[path[0]] = path[1:]

    result = {}

    for root in forest:
        recurse(root, [])

    return result


if __name__ == "__main__":
    hierarchy = {
        "A": ["C"],
        "B": ["C"],
        "C": ["F"],
        "D": ["E"],
        "E": ["F"],
        "F": [""]
    }
    print(transitive_closure(hierarchy))

Now, there's some inconsistency in the expected output. Either "" counts as a node value or it doesn't. If we count it, you can use

result[path[0]] = path[1:] + [root]

but then you'll see "" at the end of every closure path because "F": [""] is the terminal point of everything in this particular forest. Or maybe you meant to use "F": [] to indicate that "F" has no children, in which case you'll still want to append the current node to the path on the base case. You could also handle this as a special value, but that strikes me as a poor design.

Additionally, c_p seems totally pointless since hierarchy contains the exact same information, with lists as values. I assume it's possible that some elements have more than a single child, otherwise it's a pretty dull data structure. As it stands, the example is basically a linked list, a degenerate tree.

This implementation should work

def get_family_tree(person):
    """ return a family tree for a Person object """

    children = person.children.all()

    if not children:
        # this person has no children, recursion ends here
        return {'name': person.name, 'children': []}

    # this person has children, get every child's family tree
    return {
        'name': person.name,
        'children': [get_family_tree(child) for child in children],
    }

Note that this will take as many database calls as there are persons. You can try to fetch all the data into memory if you run into performance issues.

Thinking About Recursion

One way to think about recursion is to start off with the base case - i.e. where the recursion will end. In your case, we know how the family tree looks like if a person has no children:

{
    'name': 'FirstPerson',
    'children': [],
}

After you have the base case(s), think about the problem where you have to perform the recursion once.

In your case, it would be parents with children, but no grand children. We know how each child's family tree should look - it's just the base case! This leads us to the solution where we return the parent's name, and a list of each child's family tree. Leading to something like:

{
    'name': FirstPerson,
    'children': [<each element is a child's family tree>]
}

Edit

Django automatically generates reverse relations for a ForeignKey.

class Person(models.Model):
    ....
    parent = models.ForeignKey('self', related_name='children', blank=True, null=True)

p = Person()
p.children.all() # automatically fetch all Person objects where parent=p

See https://docs.djangoproject.com/en/1.9/ref/models/fields/#foreignkey

A very simple solution would be to create a collection containing your starting node when you call compute_children for the first time and before the loop that you have, add all the children to the collection, ignoring any child that has already found its way into the collection.

In graph-theory this kind of approach is usually referred to as coloring, that is, you store what nodes were already visited somehow, so in the future you will not revisit the same nodes if a cycle is present.

Here is a pure XSLT solution -- efficiently using keys (equivalent to hash-tables) and just 23 lines -- the shortest solution so far.

This is also computationally the simplest one -- compare nesting level 1 to nesting level of 4 - 5 ...

This solution is tail-recursive meaning that any good XSLT processor optimizes it with iteration, thus avoiding the possibility of stack-overflow, as the maximum call-stack depth remains constant (1).

<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
 <xsl:output method="text"/>

 <xsl:key name="kNodeByChild" match="node" use="@child"/>
 <xsl:key name="kNodeByName" match="node" use="@name"/>

  <xsl:template match="/*">
    <xsl:apply-templates select="node[not(key('kNodeByChild', @name))]"/>
  </xsl:template>

  <xsl:template match="node[not(key('kNodeByName', @child))]">
    <xsl:param name="pParentPath"/>
    <xsl:value-of select="concat($pParentPath, @name, ' ---> ', @child, '&#xA;')"/>
  </xsl:template>

  <xsl:template match="node">
    <xsl:param name="pParentPath"/>

    <xsl:apply-templates select="key('kNodeByName', @child)">
      <xsl:with-param name="pParentPath" select="concat($pParentPath, @name, ' ---> ')"/>
    </xsl:apply-templates>
  </xsl:template>
</xsl:stylesheet>

When this transformation is applied on the provided XML document:

<nodes>
    <node name="Car" child="Engine"/>
    <node name="Car" child="Wheel"/>
    <node name="Engine" child="Piston"/>
    <node name="Engine" child="Carb"/>
    <node name="Carb" child="Bolt"/>
    <node name="Spare Wheel"/>
    <node name="Bolt" child="Thread"/>
    <node name="Carb" child="Foat"/>
    <node name="Truck" child="Engine"/>
    <node name="Engine" child="Bolt"/>
    <node name="Wheel" child="Hubcap"/>
</nodes>

The wanted, correct result is produced:

Car ---> Engine ---> Piston
Car ---> Engine ---> Carb ---> Bolt ---> Thread
Car ---> Engine ---> Carb ---> Foat
Car ---> Engine ---> Bolt ---> Thread
Car ---> Wheel ---> Hubcap
Spare Wheel ---> 
Truck ---> Engine ---> Piston
Truck ---> Engine ---> Carb ---> Bolt ---> Thread
Truck ---> Engine ---> Carb ---> Foat
Truck ---> Engine ---> Bolt ---> Thread

I think it might be more helpful to you if I post a working example of how to do this, as opposed to going through where you code is having problems. We might get to the point of understanding a lot faster that way. Your code has the correct idea that it needs to track the depth as it goes. But the only thing it is missing is a sense of nested depth (tree). It only knows the previous node_count, and then its current child count.

My example uses a closure to start the depth tracking object, and then creates an inner function to do the recursive part.

def recurse(box):

    boxes = not isinstance(box, (list, tuple)) and [box] or box

    depth = [1]

    def wrapped(box):

        depthStr = '.'.join([str(i) for i in depth])
        print "%s %s" % (depthStr, box.name)

        depth.append(1)
        for child in box.boxItems:
            wrapped(child)
            depth[-1] += 1
        depth.pop()

    for box in boxes:
        wrapped(box)
        depth[0] += 1

Sample output from your examples:

>>> recurse(example)
1 Example Box
1.1 Big Box
1.1.1 Normal Box
1.1.2 Friendly Box
1.2 Cool Box

>>> recurse([example, example])
1 Example Box
1.1 Big Box
1.1.1 Normal Box
1.1.2 Friendly Box
1.2 Cool Box
2 Example Box
2.1 Big Box
2.1.1 Normal Box
2.1.2 Friendly Box
2.2 Cool Box

Breaking this down:

We first accept a box argument, and automatically convert it locally to a list, if you had only passed in a single box item. That way you can pass either one box objects, or a list/tuple of them.

depth is our depth tracker. Its a list of ints that we will build up and shrink down as the recursion happens. It starts at 1 for the first item / first level. Over time it can look like this: [1,1,2,3,1] depending on how deep it traverses. This is the major difference between my code and yours. Each recursion has access to this state.

Now we have this inner wrapped function. Its going to take a current box item and print it, and then iterate over its children. We get our print string by joining the current depth list, and then the name.

Every time we drop down into a child list, we add a starting level 1 to our depth list, and when we come out of that child loop, we pop it back off again. For every child in that loop, we increment that last item up.

Outside of that wrapped inner function, we then start the whole thing by looping over our initial boxes, calling wrapped and then incrementing our first level.

The inner wrapped function uses the depth list in a closure. I am willing to bet that others can offer some further improvements on this, but its what I came up with for an example.

Note about the args for the function

We could have also designed recurse to instead take a variable length argument list, instead of checking for a list. It would look like this (and would get rid of that first boxes = check):

def recurse(*boxes):
    #boxes will always come in as a tuple no matter what

>>> recurse(example)
>>> recurse(example, example, example)

And if you originally start with a list of box items, you can pass it by doing:

>>> boxes = [example, example, example]
>>> recurse(*example)    # this will unpack your list into args

You can use networkx to solve the problem. Note if you use networkx you don't need the highest columns. The main function to find all paths is all_simple_paths

# Python env: pip install networkx
# Anaconda env: conda install networkx
import networkx as nx

# Create network from your dataframe
#G = nx.from_pandas_edgelist(df, source='parent', target='child',
#                            create_using=nx.DiGraph)

# For older versions of networkx
G = nx.DiGraph()
for _, (source, target) in df[['parent', 'child']].iterrows():
    G.add_edge(source, target)

# Find roots of your graph (a root is a node with no input)
roots = [node for node, degree in G.in_degree() if degree == 0]

# Find leaves of your graph (a leaf is a node with no output)
leaves = [node for node, degree in G.out_degree() if degree == 0]

# Find all paths
paths = []
for root in roots:
  for leaf in leaves:
    for path in nx.all_simple_paths(G, root, leaf):
        paths.append(path)

# Create a new dataframe
out = pd.DataFrame(paths).fillna('')
out.columns = reversed(out.add_prefix('level ').columns)

Output:

>>> out
  level 3 level 2 level 1 level 0
0       a       b       c        
1       a       b       d       e

you should probably use a defaultdictionary for this:

from collections import defaultdict    

itemdict = defaultdict(list)
for id, parent_id in itemlist:
   itemdict[parent_id].append(id)

then you can recursively print it (with indentation) like

def printitem(id, depth=0):
    print '  '*depth, id
    for child in itemdict[id]:
        printitem(child, depth+1)

More Python thing than Blender's one, but you can:

import bpy

def find_meshes_recursive( root, levels=10, meshes=None ):
    # Initialize the result once
    if meshes is None:
        meshes = []

    def recurse( parent, result, level, levels ):
        # Does nothing if level is reached
        if level < levels:
            # Keeps meshes
            if parent.type == 'MESH':
                result.append(parent)
            # Look over children at next level
            for child in parent.children:
                recurse( child, result, level + 1, levels )
    
    recurse( root, meshes, 0, levels )
    return meshes

root = bpy.context.object

meshes = find_meshes_recursive(root, levels = 10)
print(meshes)

Note that you can also do it in non recursive way:

def find_meshes(root, levels=10, meshes=None):
    meshes = [] if meshes is None else meshes
    
    parents = [root]
    while levels > 0 and parents:
        meshes.extend([obj for obj in parents if obj.type == 'MESH'])
        parents = [child for obj in parents for child in obj.children]
        levels -= 1
        
    return meshes

As you said, it's not really a tree, but more like a directed acyclic graph, so you can't map each child to just one parent; it'd have to be a list of parents. Also, given your use case, I'd suggest mapping parents to their lists of children instead.

relations = [[123,234],[234,345],[123,235],[123,236],[124,236],[236,346]]

children = {}
for p, c in relations:
    children.setdefault(p, []).append(c)
roots = set(children) - set(c for cc in children.values() for c in cc)

You can then use a recursive function similar to the one you already have to get all the children to a given root node (or any parent node). The root itself is not in the list, but can easily be added.

def all_children(p):
    if p not in children:
        return set()
    return set(children[p] + [b for a in children[p] for b in all_children(a)])

print({p: all_children(p) for p in roots})
# {123: {234, 235, 236, 345, 346}, 124: {346, 236}}

Below is a table where each column represents a stack frame (left to right). A tuple indicates what the local variables remaining and start have as values (they are local and never change value). The value of i is implicitly represented by showing the argument with which append is executed.

At the far right combination is represented, which is a single list to which all executions of find_combinations_recursively have access. An asterisk suffix means that combination is printed.

For input 5:

For input 3:

I hope this clarifies what happens.

Following should do good for you :

class BinaryTree:
  def __init__(self, root, nodes):
    self._root = root
    self._nodes = nodes
    self._parent_tree = None

    if self._root is not None:
        for node in self._nodes:
            if node is not None:
                node._parent_tree = self
    else:
        pass