BST：返回大于键的第一个条目

Question

我正在编写一个 Java 方法，该方法采用二叉搜索树 (BST) T 和键 k，并返回大于 k 的第一个条目，该条目将出现在中序遍历中。如果 k 不存在或不存在大于 k 的键，则返回 null。例如，当应用于下图中的 BST 时，如果 k = 23，则应返回 29；如果 k = 32，则应返回 null。

http://imgur.com/fpNk9fT

伪代码为：

findFirstEntryLargerThanKey(BSTNode t, int key)
// go left
findFirstEntryLargerThanKey(t.left, key);
// visit the node
if t.nodeValue == key 
key exists, set a boolean value to true
else if t.nodeValue > key
check if this node value is the first entry larger than key
// go right
findFirstEntryLargerThanKey(t.right, key);

我写到现在的代码：

boolean found = false;
int x = 0;
public Integer findFirstEntryLargerThanKey(BSTNode t, int key) { 
    // the scan terminates on an empty subtree
    if (t != null) {


        // descend left 
        findFirstEntryLargerThanKey(t.left, key); 
        // visit the node
        if (t.nodeValue == key){
            found = true;
        }

        else if (t.nodeValue > key && found == true && ? && ?){
        x = t.nodeValue;

        }
        // descend right
        findFirstEntryLargerThanKey(t.right, key);
        return x;
    } 

    return null;
}

我需要有关我必须使用的条件的帮助。

Answer 1

按顺序进行遍历，它将按升序打印树键。同时继续比较密钥并打印大于您的密钥的第一个密钥..时间复杂度将小于 O(n)

Answer 2

找到后可以直接返回答案，因为 x 是全局声明的。

你的函数应该是这样的：

boolean found = false;
int x = 0;
public Integer findFirstEntryLargerThanKey(BSTNode t, int key) { 
    // the scan terminates on an empty subtree
    if (t != null) {


        // descend left 
        findFirstEntryLargerThanKey(t.left, key); 
        // visit the node
        if (t.nodeValue == key){
            found = true;
        }

        else if (t.nodeValue > key && found == true){
            x = t.nodeValue;
            return x;
        }
        // descend right
        findFirstEntryLargerThanKey(t.right, key);
        return x;
    } 

    return null;
}

或者，做这样的事情：

int x = 0;
public Integer findFirstEntryLargerThanKey(BSTNode t, int key) { 
    // the scan terminates on an empty subtree
    if (t != null) {


        // descend left 
        findFirstEntryLargerThanKey(t.left, key); 
        // visit the node
        if (t.nodeValue > key){
            x = t.nodevalue;
            return x;
        }
        // descend right
        findFirstEntryLargerThanKey(t.right, key);
        return x;
    } 

    return null;
}

Answer 3

让我们通过两个额外的步骤尝试通常的键搜索：

 * Whenever we go left from a parent to a child, 
   remember the parent as a potential answer.
 * If the key is found and it has a right subtree, 
   then the answer is left-most (smallest) node of that subtree.

FindFirstEntryLargerThanKey(BSTNode t, int key) {
  BSTNode result_so_far = null;
  for (BSTNode cur = t; cur; ) {
    if (key < cur->key) {
      result_so_far = cur;
      cur = cur->left;
    }
    else if (key == cur->key) {
      if (cur->right) {
        result_so_far = LeftMostNode(cur->right);
      }
      break;
    }
    else {
      cur = cur->right;
    }
  }
  return result_so_far;
}

Answer 4

    try this out


    public Integer findFirstEntryLargerThanKey(BSTNode t, int key) { 
Integer x =null;
        // the scan terminates on an empty subtree
        if (t != null && x!=null) {


            // descend left 
            findFirstEntryLargerThanKey(t.left, key); 
            // visit the node


             if (t.nodeValue > key  ||t.nodeValue==key){
                x = t.nodeValue;


            }
            // descend right
            findFirstEntryLargerThanKey(t.right, key);

        } 

        return x;
    }