EPI Python 9.16 Code - Redundant condition?

**interviewing.joe** · February 16, 2018, 1:35pm

construct_right_sibling_tree() and populate_children_next_field() both check this specific terminating condition (tree.left, start_node.left).

Is this deliberately redundant or is there a reason for this check to exist in both the methods?

**tsunghsienlee** · February 16, 2018, 5:38pm

That is what is necessary to make it works because there is no need to go deeper level to connect your children’s sibling.

**interviewing.joe** · February 17, 2018, 6:40am

Isn’t the check for tree.left in construct_right_sibling_tree() sufficient to prevent the code from going deeper (to the leaves and below)?

Am I overseeing a case where checking start_node.left in the called method populate_children_next_field() is crucial for the algorithm to work?

**tsunghsienlee** · February 17, 2018, 6:50am

I would suggest you to use our judge framework to test your algorithm and then you shall understand that more!

**interviewing.joe** · February 17, 2018, 11:45pm

Thanks, I just ran my code using the EPI Judge framework. It was logical to me that we don’t need to repeat the check in two places, but the framework helped confirm this.

**tsunghsienlee** · February 19, 2018, 12:57am

Hi @interviewing.joe,

Would you mind to share your working code here as I am curious about this?

**interviewing.joe** · February 19, 2018, 1:48am

Sure. We can refer the official Solutions (http://elementsofprogramminginterviews.com/solutions/) for “Compute the right sibling tree” problem:

```
def construct_right_sibling(tree):
```

    def populate_children_next_field(start_node):

        while start_node and start_node.left:

            # Populate left child's next field.

            start_node.left.next = start_node.right

            # Populate right child's next field if iter is not the last node of

```
            # level.
```

            start_node.right.next = start_node.next and start_node.next.left

            start_node = start_node.next

```
    while tree and tree.left:
```

        populate_children_next_field(tree)

```
        tree = tree.left
```

The check for tree.left on line 10 and start_node.left on line 4 are redundant - only one check on the left node is sufficient for the program to provide the correct result.

**tsunghsienlee** · February 20, 2018, 7:41pm

Turns out it is just inconsistency of solutions between Python and other languages, we do exclude this check in C++ and Java.