Data structures 如何查找二叉树中是否存在节点（按索引，而不是按值）？

给定一个完整的二叉树，其中节点从1索引到N，索引1是根，N是树中的节点数。我们能否在OlogN时间复杂度中找到树中是否存在具有特定索引的节点

How is the indexing done?
for a node say it has      index x
                          /        \
             node.left is 2*x    node.right is 2*x+1

下面我编写了在上运行的代码

当节点位于右子树深处时，ON解决方案似乎效率很低。我们可以避免访问根级别的左子树吗

利用一个完整的二叉树这一事实，在OlogN时间复杂度方面有可能实现这一目标吗

##TreeNode object
class TreeNode(object):
    def __init__(self, x):
        self.val = x
        self.left = None
        self.right = None

##findIndex
def findIndex(root,index,target):
    if root == None:
        return False
    if index == target:
        return True

    leftSide = findIndex(root.left,2*index,target)
    rightSide = findIndex(root.right,2*index+1,target)

    return (leftSide or rightSide)

##Create tree
root = TreeNode(1)
root.left = TreeNode(2)
root.right = TreeNode(3)
root.left.left = TreeNode(4)
root.left.right = TreeNode(5)

"""
For the sake of simplicity, 
the tree node values are the same as their index.
                1
               /  \
             2     3
            / \  
           4   5
"""

##call findIndex

## findIndex(root, startIndex, targetIndex) 

print findIndex(root,1,1) ## returns True
print findIndex(root,1,8) ## returns False

---

因为我们已经知道左节点是2*n，右节点是2*n+1。让我们首先从输入中给定的索引开始，找出路径。 例如，如果我们的索引是10，那么我们知道10应该在5的左边，反过来应该在2的右边，也就是根或1的左边。

---

所以路径是左，右，左。现在，只要在二叉树中遍历此路径，如果节点存在，则返回null，否则返回true或false。

因为我们已经知道左节点是2*n，右节点是2*n+1。让我们首先从输入中给定的索引开始，找出路径。 例如，如果我们的索引是10，那么我们知道10应该在5的左边，反过来应该在2的右边，也就是根或1的左边。 所以路径是左，右，左。现在，只要在二叉树中遍历此路径（如果节点存在，则为null），就返回true或false。

使用堆栈：

除以2，因为我们知道每个节点的索引是其父节点的两倍。如果父级为i，则左侧子级为2i，右侧子级为2i+1。 我们有一个索引，所以我们推动它的父级到达根到堆栈。 逐个从堆栈中移除，并选择基于奇偶存在的决策。最后，如果该节点存在，则表示树具有该节点。 使用堆栈：

除以2，因为我们知道每个节点的索引是其父节点的两倍。如果父级为i，则左侧子级为2i，右侧子级为2i+1。 我们有一个索引，所以我们推动它的父级到达根到堆栈。 逐个从堆栈中移除，并选择基于奇偶存在的决策。最后，如果该节点存在，则表示树具有该节点。

---

我仍然对索引在树中的排列方式感到困惑。对于一个节点，比如它有索引x，node.left是2*x，node.right是2*x+1so，通过连续除以2，你可以计算出path@Constructor，你能详细说明一下这个想法吗？我试图观察左右子树索引中的一种模式，但我找不到类似的东西。索引11，除以2:11 5 2 1我仍然对索引在树中的排列方式感到困惑。对于一个节点来说，它有索引x，node.left是2*x，node.right是2*x+1。因此，通过连续除以2，可以计算出path@Constructor，你能详细说明一下这个想法吗？我试图观察左右子树索引中的一种模式，但我找不到类似的东西。指数11，除以2:11521

 private boolean nodeExist(TreeNode node, int idx){
        Stack<Integer> stack = new Stack<>();
        int temp = idx;
        while(temp !=1){
            stack.push(temp);
            temp /=2;
        }
        while(!stack.isEmpty()){
            if(stack.pop() %2 ==0){
                node = node.left;
            }else{
                node = node.right;
            }
        }
        
        return node !=null;
    }