CS61A:LAB8
Let me walk through each of these Python operations step by step, assuming `Tree` is a class that represents a tree structure with a `label` and `branches` (as is typical in Python tree implementations).
Initial Tree Definition
The `Tree` class likely looks something like this:
```python
class Tree:
def __init__(self, label, branches=[]):
self.label = label
self.branches = list(branches)
```
Step-by-Step Evaluation
1. First Attempt (Error)
```python
>>> t = Tree(1, Tree(2))
```
This will raise an error because the second argument should be an iterable (like a list) of branches, not a single Tree object.
2. Correct Initialization
```python
>>> t = Tree(1, [Tree(2)])
```
Now `t` is a tree with:
• Label: 1
• Branches: [Tree(2)]
3. Accessing Label
```python
>>> t.label
1
```
Returns the label of the root node.
4. Accessing First Branch
```python
>>> t.branches[0]
```
Returns the first branch (which is a Tree with label 2).
5. Accessing Branch's Label
```python
>>> t.branches[0].label
2
```
Returns the label of the first branch.
6. Modifying Root Label
```python
>>> t.label = t.branches[0].label
>>> t
```
Now `t.label` becomes 2 (same as its first branch's label). The tree structure is now:
• Label: 2
• Branches: [Tree(2)]
7. Adding a New Branch
```python
>>> t.branches.append(Tree(4, [Tree(8)]))
```
Adds a new branch:
• Label: 4
• With its own branch: Tree(8)
Now the tree looks like:
• Label: 2
• Branches: [Tree(2), Tree(4, [Tree(8)])]
8. Counting Branches
```python
>>> len(t.branches)
2
```
There are now 2 branches.
9. First Branch
```python
>>> t.branches[0]
```
Still the original Tree(2).
10. Second Branch
```python
>>> t.branches[1]
```
The newly added Tree(4, [Tree(8)]).
Final Tree Structure
Visually, the final tree looks like:
```
2
/ \
2 4
/
8
```
Key Points
• Tree initialization requires branches to be in an iterable (usually a list)
• `label` stores the node's value
• `branches` is a list of child trees
• You can modify both labels and branches after creation
• Branches can themselves have branches, creating recursive structures
This demonstrates the basic operations for creating and modifying tree structures in Python.
def cumulative_mul(t):
"""Mutates t so that each node's label becomes the product of its own
label and all labels in the corresponding subtree rooted at t.
>>> t = Tree(1, [Tree(3, [Tree(5)]), Tree(7)])
>>> cumulative_mul(t)
>>> t
Tree(105, [Tree(15, [Tree(5)]), Tree(7)])
>>> otherTree = Tree(2, [Tree(1, [Tree(3), Tree(4), Tree(5)]), Tree(6, [Tree(7)])])
>>> cumulative_mul(otherTree)
>>> otherTree
Tree(5040, [Tree(60, [Tree(3), Tree(4), Tree(5)]), Tree(42, [Tree(7)])])
"""
"*** YOUR CODE HERE ***"
for b in t.branches:
cumulative_mul(b)
product = t.label
for b in t.branches:
product *= b.label
t.label = product
def prune_small(t, n):
"""Prune the tree mutatively, keeping only the n branches
of each node with the smallest labels.
>>> t1 = Tree(6)
>>> prune_small(t1, 2)
>>> t1
Tree(6)
>>> t2 = Tree(6, [Tree(3), Tree(4)])
>>> prune_small(t2, 1)
>>> t2
Tree(6, [Tree(3)])
>>> t3 = Tree(6, [Tree(1), Tree(3, [Tree(1), Tree(2), Tree(3)]), Tree(5, [Tree(3), Tree(4)])])
>>> prune_small(t3, 2)
>>> t3
Tree(6, [Tree(1), Tree(3, [Tree(1), Tree(2)])])
"""
while len(t.branches) > n: # Loop as long as there are more than n branches
largest = max(t.branches, key=lambda b: b.label) # Find the branch with the largest label
t.branches.remove(largest) # Remove that branch
for b in t.branches: # Recursively prune the remaining branches
prune_small(b, n)
def delete(t, x):
"""Remove all nodes labeled x below the root within Tree t. When a non-leaf
node is deleted, the deleted node's children become children of its parent.
The root node will never be removed.
>>> t = Tree(3, [Tree(2, [Tree(2), Tree(2)]), Tree(2), Tree(2, [Tree(2, [Tree(2), Tree(2)])])])
>>> delete(t, 2)
>>> t
Tree(3)
>>> t = Tree(1, [Tree(2, [Tree(4, [Tree(2)]), Tree(5)]), Tree(3, [Tree(6), Tree(2)]), Tree(4)])
>>> delete(t, 2)
>>> t
Tree(1, [Tree(4), Tree(5), Tree(3, [Tree(6)]), Tree(4)])
>>> t = Tree(1, [Tree(2, [Tree(4), Tree(5)]), Tree(3, [Tree(6), Tree(2)]), Tree(2, [Tree(6), Tree(2), Tree(7), Tree(8)]), Tree(4)])
>>> delete(t, 2)
>>> t
Tree(1, [Tree(4), Tree(5), Tree(3, [Tree(6)]), Tree(6), Tree(7), Tree(8), Tree(4)])
"""
new_branches = []
for b in t.branches:
delete(b, x)
if b.label == x:
new_branches.extend(b.branches)
else:
new_branches.append(b)
t.branches = new_branches
def max_path_sum(t):
"""Return the maximum path sum of the tree.
>>> t = Tree(1, [Tree(5, [Tree(1), Tree(3)]), Tree(10)])
>>> max_path_sum(t)
11
"""
"*** YOUR CODE HERE ***"
if t.is_leaf:
return t.label
else:
sum_num = [max_path_sum(b) for b in t.branches]
return max(sum_num) + t.label
class Tree:
"""A tree has a label and a list of branches.
>>> t = Tree(3, [Tree(2, [Tree(5)]), Tree(4)])
>>> t.label
3
>>> t.branches[0].label
2
>>> t.branches[1].is_leaf()
True
"""
def __init__(self, label, branches=[]):
self.label = label
for branch in branches:
assert isinstance(branch, Tree)
self.branches = list(branches)
def is_leaf(self):
return not self.branches
def __repr__(self):
if self.branches:
branch_str = ', ' + repr(self.branches)
else:
branch_str = ''
return 'Tree({0}{1})'.format(repr(self.label), branch_str)
def __str__(self):
return '\n'.join(self.indented())
def indented(self):
lines = []
for b in self.branches:
for line in b.indented():
lines.append(' ' + line)
return [str(self.label)] + lines