有效地找到二叉搜索树中的第 k 个最小元素？

Question

我今天面临以下面试问题，我想出了下面提到的递归和迭代解决方案，但不知何故面试官不高兴。我不知道为什么。

给定一棵二叉搜索树，找出其中第 k 个最小的元素。

有没有更好的方法以递归或迭代的方式解决这个问题？

  /*****************************************************
   *
   * Kth Smallest Recursive
   *
   ******************************************************/
  public int kthSmallestRecursive(TreeNode root, int k) {
    int count = countNodes(root.left);
    if (k <= count) {
      return kthSmallestRecursive(root.left, k);
    } else if (k > count + 1) {
      return kthSmallestRecursive(root.right, k - 1 - count);
    }

    return root.data;
  }

  public int countNodes(TreeNode n) {
    if (n == null)
      return 0;

    return 1 + countNodes(n.left) + countNodes(n.right);
  }

  /*****************************************************
   *
   * Kth Smallest Iterative
   *
   ******************************************************/

  public int kthSmallestIterative(TreeNode root, int k) {
    Stack<TreeNode> st = new Stack<>();

    while (root != null) {
      st.push(root);
      root = root.left;
    }

    while (k != 0) {
      TreeNode n = st.pop();
      k--;
      if (k == 0)
        return n.data;
      TreeNode right = n.right;
      while (right != null) {
        st.push(right);
        right = right.left;
      }
    }

    return -1;
  }

我提到了上述解决方案的复杂性为 O(depth of node)，即 O(log n)。

我的迭代版本占用了额外的空间。有没有什么办法不用多余的空间？

Answer 1

首先，我怀疑它是否需要 O(logn)。普通二叉搜索树至少为 O(n)。

对于vanilla bst，您可以进行迭代或递归，两者都是模拟相同的忽略器遍历过程，具有最差的时间复杂度 O(n) 和空间复杂度 O(logn)（请注意，即使是递归解决方案也可能需要 O(logn)堆栈空间）。

但是，如果您可以稍微更改数据结构，则可以加快速度或使用更少的空间：

1. 如果您使用二叉搜索树，每个节点记录其下的总节点数，您可以将其视为排序数组并使用 O(logn)时间和 O(1) 空间。

2. 如果您使用的二叉搜索树的每个节点都包含父指针和状态指示符，您可以采用与普通解决方案相同的方式遍历树。在途中，您标记节点是否为 a。未遍历 2. 已遍历其左节点 3. 已遍历两个节点。那么你可以在 O(n) 时间和 O(1) 空间内完成。

Answer 2

 public int printInorder(Node node, int k) 
    { 
        if (node == null || k <= 0) //Stop traversing once you found the k-th smallest element
            return k; 

        /* first recur on left child */
        k = printInorder(node.left, k); 

        k--;
        if(k == 0) {  
            System.out.print(node.key);
        }

        /* now recur on right child */
        return printInorder(node.right, k);
    } 

在递归方法的countNodes() 方法中，您正在遍历每个节点的树以进行计数。 countNodes() 操作是 O(n) 并且您正在对 log(n) 个节点执行操作。所以你的递归解决方案的复杂性顺序是O(n^2)，而我上面提到的方法在 O(n) 中解决。