Data structures BST，正在查找下一个最高节点

在BST，根据节目采访曝光

“给定一个节点，您甚至可以在O（log（n））时间内找到下一个最高的节点”第65页

BST中的节点将右子节点作为下一个最高节点，那么为什么是O（log（n））？请更正

---

首先回答问题，然后就您的评论“BST中的一个节点具有右子节点作为下一个最高节点”（假设此处“下一个最高节点”表示下一个顺序值）否定它-不，它没有

如果右边的孩子没有左边的子树，情况可能就是这样，但事实并非总是如此

下一个顺序值（我使用的是该术语，而不是“最高”，因为后者可能与树高混淆，“最大”表示一个特定的（从低到高）顺序，而不是任何顺序）值来自两个位置中的一个

---

首先，如果当前节点有一个右子节点，则移动到该右子节点，然后，只要可以看到左子节点，就移动到该右子节点

换句话说，以

S

和

D

作为源（当前）和目标（下一个最大）：

---

由于工作量与树的高度成正比（我们要么向下，要么向上然后向下），平衡树的时间复杂度将为

O（logN）

，因为高度与项数有

logN

关系

这本书在这里谈论的是平衡树，因为它包含了关于它们的片段，如：

• 这种查找是一种快速的操作，因为在每次迭代中都会从搜索中删除一半的节点
• 查找是二进制搜索树中的

  O（log（n））

  操作
• 如果您可以保证在每次迭代中剩余的要搜索的节点数将减半或几乎减半，则查找仅为

  O（log（n））

因此，虽然它在最后一句话中承认BST可能不平衡，但

O（logn）

属性仅适用于那些不平衡的变体

对于非平衡树，复杂性（最坏情况）将是

O（n）

，因为最终可能会出现退化树，如：

S             D
 \           /
  x         x
   \         \
    x         x
     \         \
      x         x
       \         \
        x         x
       /           \
      D             S

---

这是我在Java中的伪实现。希望能有帮助

节点结构

public Class Node{

int value {get, set};
Node leftChild {get,set};
Node rightChild{get, set};
Node parent{get,set};
}

public Node findNextBiggest(Node n){
    Node temp=n;
    if(n.getRightChild()==null)
    {
        while(n.getParent()!=null && temp.getValue()>n.getParent().getValue())
        {
            n=n.getParent():
        }
        return n.getParent();
    }
    else
    {
        n=n.getRightChild();
        while (n.getLeftChild()!=null && n.getLeftChild().getValue()>temp.getValue())
        {
            n=n.getLeftChild();
        }
    return n;
    }
}

查找下一个最高节点的函数

public Class Node{

int value {get, set};
Node leftChild {get,set};
Node rightChild{get, set};
Node parent{get,set};
}

public Node findNextBiggest(Node n){
    Node temp=n;
    if(n.getRightChild()==null)
    {
        while(n.getParent()!=null && temp.getValue()>n.getParent().getValue())
        {
            n=n.getParent():
        }
        return n.getParent();
    }
    else
    {
        n=n.getRightChild();
        while (n.getLeftChild()!=null && n.getLeftChild().getValue()>temp.getValue())
        {
            n=n.getLeftChild();
        }
    return n;
    }
}

---

我认为，我们可以通过简单地找到节点的有序后继节点来找到下一个最高的节点

台阶-

• 首先，转到节点的右侧子节点
• 然后尽可能向左移动。到达叶节点时，打印该叶节点，因为该节点是相对于给定节点的下一个最高节点

---

如果没有合适的子节点该怎么办？根据你的说法，下一个最高节点的含义是什么？可能是下一个更大的节点。然后，我不知道。在很多情况下，你是否否定了这个问题？可能是重复的，它是如何记录的（n）？@user2901020在一个平衡树中，

深度是O（logn）。在查找下一个节点时，最多向上搜索
depth
次，然后最多向下搜索
depth
次-当求和时，结果是O（logn）。要实现它，如何找到给定节点的父节点，没有返回指针？简而言之，你能告诉我这是如何实现的吗？对我来说，它是这样的，首先计算源节点的深度，然后计算它的父节点，然后检查源节点是它的右节点还是左节点。我很困惑，你能给我一个正确的方向吗？@user2901020，最简单的方法是在每个节点上都有一个父节点指针。我将为函数添加一些伪代码。我同意您的解决方案，但这样您就修改了节点本身，如果没有空间存储父指针，您的方法是什么。。
public Node findNextBiggest(Node n){
    Node temp=n;
    if(n.getRightChild()==null)
    {
        while(n.getParent()!=null && temp.getValue()>n.getParent().getValue())
        {
            n=n.getParent():
        }
        return n.getParent();
    }
    else
    {
        n=n.getRightChild();
        while (n.getLeftChild()!=null && n.getLeftChild().getValue()>temp.getValue())
        {
            n=n.getLeftChild();
        }
    return n;
    }
}