1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
|
# Bugs Everywhere, a distributed bugtracker
# Copyright (C) 2008-2010 Gianluca Montecchi <gian@grys.it>
# W. Trevor King <wking@drexel.edu>
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License along
# with this program; if not, write to the Free Software Foundation, Inc.,
# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
"""
Define a traversable tree structure.
"""
import libbe
if libbe.TESTING == True:
import doctest
class Tree(list):
"""
Construct
+-b---d-g
a-+ +-e
+-c-+-f-h-i
with
>>> i = Tree(); i.n = "i"
>>> h = Tree([i]); h.n = "h"
>>> f = Tree([h]); f.n = "f"
>>> e = Tree(); e.n = "e"
>>> c = Tree([f,e]); c.n = "c"
>>> g = Tree(); g.n = "g"
>>> d = Tree([g]); d.n = "d"
>>> b = Tree([d]); b.n = "b"
>>> a = Tree(); a.n = "a"
>>> a.append(c)
>>> a.append(b)
>>> a.branch_len()
5
>>> a.sort(key=lambda node : -node.branch_len())
>>> "".join([node.n for node in a.traverse()])
'acfhiebdg'
>>> a.sort(key=lambda node : node.branch_len())
>>> "".join([node.n for node in a.traverse()])
'abdgcefhi'
>>> "".join([node.n for node in a.traverse(depth_first=False)])
'abcdefghi'
>>> for depth,node in a.thread():
... print "%*s" % (2*depth+1, node.n)
a
b
d
g
c
e
f
h
i
>>> for depth,node in a.thread(flatten=True):
... print "%*s" % (2*depth+1, node.n)
a
b
d
g
c
e
f
h
i
>>> a.has_descendant(g)
True
>>> c.has_descendant(g)
False
>>> a.has_descendant(a)
False
>>> a.has_descendant(a, match_self=True)
True
"""
def __cmp__(self, other):
return cmp(id(self), id(other))
def __eq__(self, other):
return self.__cmp__(other) == 0
def __ne__(self, other):
return self.__cmp__(other) != 0
def branch_len(self):
"""
Exhaustive search every time == SLOW.
Use only on small trees, or reimplement by overriding
child-addition methods to allow accurate caching.
For the tree
+-b---d-g
a-+ +-e
+-c-+-f-h-i
this method returns 5.
"""
if len(self) == 0:
return 1
else:
return 1 + max([child.branch_len() for child in self])
def sort(self, *args, **kwargs):
"""
This method can be slow, e.g. on a branch_len() sort, since a
node at depth N from the root has it's branch_len() method
called N times.
"""
list.sort(self, *args, **kwargs)
for child in self:
child.sort(*args, **kwargs)
def traverse(self, depth_first=True):
"""
Note: you might want to sort() your tree first.
"""
if depth_first == True:
yield self
for child in self:
for descendant in child.traverse():
yield descendant
else: # breadth first, Wikipedia algorithm
# http://en.wikipedia.org/wiki/Breadth-first_search
queue = [self]
while len(queue) > 0:
node = queue.pop(0)
yield node
queue.extend(node)
def thread(self, flatten=False):
"""
When flatten==False, the depth of any node is one greater than
the depth of its parent. That way the inheritance is
explicit, but you can end up with highly indented threads.
When flatten==True, the depth of any node is only greater than
the depth of its parent when there is a branch, and the node
is not the last child. This can lead to ancestry ambiguity,
but keeps the total indentation down. E.g.
+-b +-b-c
a-+-c and a-+
+-d-e-f +-d-e-f
would both produce (after sorting by branch_len())
(0, a)
(1, b)
(1, c)
(0, d)
(0, e)
(0, f)
"""
stack = [] # ancestry of the current node
if flatten == True:
depthDict = {}
for node in self.traverse(depth_first=True):
while len(stack) > 0 \
and id(node) not in [id(c) for c in stack[-1]]:
stack.pop(-1)
if flatten == False:
depth = len(stack)
else:
if len(stack) == 0:
depth = 0
else:
parent = stack[-1]
depth = depthDict[id(parent)]
if len(parent) > 1 and node != parent[-1]:
depth += 1
depthDict[id(node)] = depth
yield (depth,node)
stack.append(node)
def has_descendant(self, descendant, depth_first=True, match_self=False):
if descendant == self:
return match_self
for d in self.traverse(depth_first):
if descendant == d:
return True
return False
if libbe.TESTING == True:
suite = doctest.DocTestSuite()
|
