Question

如何在BST中找到第N个最大节点？

在进行BST的In Order Traversal时，我是否保留计数变量？当count = N ???

时返回元素

Answer 1

这个想法很简单：按每个节点值的降序遍历树。到达第N个节点时，打印该节点值。这是递归代码。

void printNthNode(Node* root, int N)
{
   if(root == NULL)
       return;

   static int index = 0; //These will initialize to zero only once as its static

   //For every Node go to the right of that node first.
   printNthNode(root->right, N);


   //Right has returned and now current node will be greatest
   if(++index == N)
   {
    printf("%d\n", root->data);
    return;
   }

   //And at last go to the left
   printNthNode(root->left, N);
}

编辑 - 根据下面的评论，由于静态局部变量，这看起来像是一次性调用函数。这可以通过传递index的包装器对象来解决，如下所示：

    class WrapIndex {
         public: int index;
    };

并且方法签名将更改为

void printNthNode(Node* root, int N, WrapIndex wrapInd)

现在，我们不需要本地静态变量;而是使用包装器对象的index。这个电话看起来像是

WrapIndex wrapInd = new WrapIndex();
wrapInd.index=0;
printNthNode(root,7,wrapInd);

wrapInd.index=0;
printNthNode(root,2,wrapInd);

Answer 2

提示：使用树的 inorder遍历。它可以按排序顺序打印出项目，因此您可以确定找到第N个最大的项目。当你“走路”时保持一个计数器，每次“访问”一个节点时递增。

编辑：虽然IVlad的答案确实更快，但它要求您在节点中保留额外信息。这个答案没有，但它是O(n)。只是指出这是一个你需要注意的权衡。

Answer 3

请参阅我的回答here。您可以在O(log n)中平均执行此操作，其中n =节点数。最坏的情况仍然是O(n)如果树不平衡（如果它是平衡的话总是O(log n)）。但是，顺序遍历始终是O(n)。

Answer 4

使用倒置的顺序tranversal.that是先去右边的孩子而不是左边的孩子。递归地，这可以如下获得：考虑递归解决方案时必须使用全局计数的最重要问题。

reverseInorder(root){
 if(root!=null){
reverseInorder(root->rightChild);
self
reverseInorder(root->leftChild);
}
}

java中的解决方案

    package datastructure.binaryTree;

import datastructure.nodes.BinaryTreeNode;


public class NthElementFromEnd {
    private BinaryTree tree=null;
    int currCount=0;
    public NthElementFromEnd(int[] dataArray) {
        this.tree=new BinaryTree(dataArray);

    }
    private void getElementFromEnd(int n){
        getElementFromEnd(this.tree.getRoot(),n);
    }
    private void getElementFromEnd(BinaryTreeNode node,int n){
        if(node!=null){
            if(currCount<n)
            getElementFromEnd(node.getRightChild(),n);
            currCount++;

            if(currCount==n)
            {
                System.out.print(" "+node.getData());
                return;
            }
            if(currCount<n)
            getElementFromEnd(node.getLeftChild(),n);
        }
    }

    public static void main(String args[]){
        int data[]={1,2,3,4,5,6,7,8,9};
        int n=2;
        new NthElementFromEnd(data).getElementFromEnd(n);
    }
}

Answer 5

int nLargeBST(node *root, int N) {
    if (!root || N < 0) {
        return -1;
    }
    nLargeBST(root->left, N);
    --N;
    if(N == 0) {
        return root->val;
    }
    nLargeBST(root->right, N);
}

Answer 6

这段代码来自我的任务，其中一个条件是不使用阵列。为了使代码更紧凑和可读，您可以使用 stringName.split（ “|”）。由于该方法是递归的，我使用stringBuilder 具有以下结构：“counter | orderOfElementToFind | dataInrequiredNode”

protected StringBuilder t(StringBuilder s)
{
    if (lc != null) 
    {
        lc.t(s);
}


if((s.toString().charAt(s.toString().length() - 1)) == '|')
{
        String str = s.toString();
    s.delete(0, s.length());

        int counter = 0, k = 0;


        String strTemp = "", newStrBuilContent = "";

        for (int i = 0, c = 0 ; i < str.length(); ++i)
        {
            if (c == 0)
            {
            if (str.charAt(i) != '|')
    {
        strTemp += str.charAt(i); 
    }
    else
    {
        counter = Integer.parseInt(strTemp);
        ++c;

        strTemp = "";
    }
            }
    else
    {

            if (str.charAt(i) != '|')
        {
            strTemp += str.charAt(i); 
            }
        else
        {
                k = Integer.parseInt(strTemp);
        }

    }

    counter ++;

            newStrBuilContent = (counter + "|" + k + "|");
    s.append(newStrBuilContent);
    if (counter == k)
    {
        double ldata = this.getData();
        s.append(ldata);

    }

}

if (rc != null) 
{
    rc.t(s);
} 

    return s;

}

和方法调用：

// the value of counter ad the beginning is 0 and data 
// segment is missing
String s = ("0|" + order +"|");
StringBuilder strBldr = new StringBuilder(s); 
String content = sTree.t(strBldr).toString();

s = "";

for (int i = 0, c = 0; i < content.length(); ++i)
{           
    if (c < 2)
{
    if (content.charAt(i) == '|')
    {  
        ++c;
        }
    }
else
{
    s += content.charAt(i);
}
}
    `

Answer 7

在每个节点维护子树的大小（root.size就像这样）。例如{2,3,1}是带有根2的二叉树，那么节点（2）的大小是3，节点（1）大小是1，节点（2）大小是1
如果你想在根节点大小为23的树中找到第4个bigt元素，请考虑它的等级
最大元素等级为23，因为根节点大小为23.所以第4大元素等级为23-4 + 1 = 20
所以我们必须在给定的树中找到第20级元素
最初将 rank = 0 标志声明为零
从根节点开始找到它的等级（等级+左子的大小+ 1），例如左子大小为16，然后根元素等级为17（等级+左子+1的大小）
< / LI>
所以我们必须寻找排名为20的元素。显然我们必须遍历其正确的孩子
遍历到右边的孩子并根据上面的公式找到正确的孩子等级（基于上面的公式，注意：现在等级标志值是17），根据等级决定是向右还是向左
重复这个过程，直到我们发现rank == 20

Answer 8

我会通过将树从最大元素转换为最小元素并在达到询问位置时返回值来实现。我实现了第二大价值的类似任务。值2是硬编码的，但是使用附加参数更改很容易：）

void BTree::findSecondLargestValueUtil(Node* r, int &c, int &v)
{
    if(r->right) {
        this->findSecondLargestValueUtil(r->right, c, v);
    }

    c++;

    if(c==2) {
        v = r->value;
        return;
    }

    if(r->left) {
        this->findSecondLargestValueUtil(r->left, c, v);
    }
}


int BTree::findSecondLargestValue()
{
    int c = 0;
    int v = -1;

    this->findSecondLargestValueUtil(this->root, c, v);

    return v;
}

Answer 9

// C++ program to find k'th largest element in BST
#include<iostream>
using namespace std;

struct Node
{
    int key;
    Node *left, *right;
};

// A utility function to create a new BST node
Node *newNode(int item)
{
    Node *temp = new Node;
    temp->key = item;
    temp->left = temp->right = NULL;
    return temp;
}

// A function to find k'th largest element in a given tree.
void kthLargestUtil(Node *root, int k, int &c)
{
    // Base cases, the second condition is important to
    // avoid unnecessary recursive calls
    if (root == NULL || c >= k)
        return;

    // Follow reverse inorder traversal so that the
    // largest element is visited first
    kthLargestUtil(root->right, k, c);

    // Increment count of visited nodes
    c++;

    // If c becomes k now, then this is the k'th largest 
    if (c == k)
    {
        cout << "K'th largest element is "
             << root->key << endl;
        return;
    }

    // Recur for left subtree
    kthLargestUtil(root->left, k, c);
}

// Function to find k'th largest element
void kthLargest(Node *root, int k)
{
    // Initialize count of nodes visited as 0
    int c = 0;

    // Note that c is passed by reference
    kthLargestUtil(root, k, c);
}

/* A utility function to insert a new node with given key in BST */
Node* insert(Node* node, int key)
{
    /* If the tree is empty, return a new node */
    if (node == NULL) return newNode(key);

    /* Otherwise, recur down the tree */
    if (key < node->key)
        node->left  = insert(node->left, key);
    else if (key > node->key)
        node->right = insert(node->right, key);

    /* return the (unchanged) node pointer */
    return node;
}

// Driver Program to test above functions
int main()
{
    /* Let us create following BST
              50
           /     \
          30      70
         /  \    /  \
       20   40  60   80 */
    Node *root = NULL;
    root = insert(root, 50);
    insert(root, 30);
    insert(root, 20);
    insert(root, 40);
    insert(root, 70);
    insert(root, 60);
    insert(root, 80);

    int c = 0;
    for (int k=1; k<=7; k++)
        kthLargest(root, k);

    return 0;
}

Answer 10

快速版本。这与Vallabh Patade所说的很接近。尝试通过没有子节点的节点时，计数器将增加1。与他有些不同。

class BinaryNode {
    var val: Int
    var left: BinaryNode?
    var right: BinaryNode?

    init(value: Int) {
        self.val = value
    }
}

func findMaxValue(_ n: Int, from root: BinaryNode?) {
    var counter = 0
    maxValue(counter: &counter, n: n, node: root)
}

private func maxValue(counter: inout Int, n: Int, node: BinaryNode?) {
    if node == nil {
        counter += 1
        return
    }
    maxValue(counter: &counter, n: n, node: node?.right)
    // If the counter has reached the nth node we're looking for.
    if counter == n {
        if let val = node?.val { print(val) }
    }
    maxValue(counter: &counter, n: n, node: node?.left)
}

Answer 11

以下是如何通过略微修改二叉搜索树的有序遍历来实现这一点 - 我们找到了第k个最大的元素;

    void kthLargest(Node node, int k, int count) {

      if(node != null) {

         nthLargest(node.left,k,count); //traversing the left node

         //while visit the node we do the following
         count++; // increment the count and check if that is equal to k
         if ( count == k ) {
           System.out.println("Node found "+node.value);
         } 

         nthLargest(node.right,k,count); //traversing the right node
      }

    }

但问题就是你要达到第k个最小元素，因此你应该调用方法调用：作为第k个最大元素=（n-k）个最小元素。

    nthLargest(root,n-k,0);

Answer 12

KST中最大的元素。学习如何思考这样的问题并通过递归来解决。 Kth Larget Explanation Recursion

二叉搜索树中的第N个最大元素

12 个答案: