如何获得非常大的二叉树中节点的级别？

Question

I'm doing a coding challenge in which I'm to find the level of a node in a binary tree of tuples if it exists. My solution isn't efficient and works only for low level nodes. How do I optimize the code to work for very large levels?

The generating pattern of the tuples is in the Node class.

from itertools import product

class Node:
    def __init__(self,data):
        self.data = data
        self.left = (self.data[0] + self.data[1], self.data[1])
        self.right = (self.data[0], self.data[0] + self.data[1])

    def lefts(self):
        self.data = self.left

    def rights(self):
        self.data = self.right

    def getter(self):
        return self.data

def solution(x,y):
    tup = (int(x),int(y))
    a = ['left', 'right']
    directions = list(product(a,repeat=int(max(tup))))

    for direction in directions:
        node = Node((1,1))
        count = 0
        for lor in direction:
            if node.getter() == tup:
                return count
            if lor == 'left':
                node.lefts()
                node = Node(node.getter())
            else:
                node.rights()
                node = Node(node.getter())
            count += 1
            
    return 'impossible'

Answer 1

For this problem it is overkill to actually create a binary tree.

What is more, it is better to look at the problem in the opposite direction, ie start at the given (x,y) "node" and determine what its parent would be, and then repeat that step to walk towards the root.

This is more interesting, since a node has only one parent, and so no alternatives have to be considered. If this path leads to the node (1, 1), then we found the solution. If however the path leads to a tuple that has a member that is not strictly positive, then we can conclude there is no solution... apparently the node is member of a distinct tree.

The "formula" to get the parent node of (x, y) is

• (x, y - x) when y > x
• (x - y, y) otherwise

Based on these observations, the program is quite straightforward:

def solution(x, y):
    count = 0
    while x > 1 and y > 1:
        if x > y:
            x -= y
        else:
            y -= x
        count += 1
    return count + abs(x - y) if min(x, y) == 1 else "impossible"