Java 在BST中找到第K个最小值--K不变

这件事我想了很久了，我的脑子都快炸糊了。可能我还没有完全理解递归

我不明白为什么k的值，在它等于0之后，不会变成负数。相反，它保持为0，直到helper函数存在。我试着传入一个初始值为零的整数，然后相加，直到它的值等于k。然而，这导致了同样的问题，一旦它等于k，它仍然是这样

有人能解释一下为什么值保持不变吗

class Solution {
        public int kthSmallest(TreeNode t, int k) {
          TreeNode tempNode = new TreeNode();
          int iter = 0;
          getKValue(t, k, tempNode); 
          return tempNode.val;
        }
        
        private static void getKValue(TreeNode t, int k, TreeNode temp) {
            if(t == null) {
                return;
            }
        
    
            getKValue(t.left, k, temp);
            
            
            k = k - 1;
            System.out.println(k);
            if(k == 0) {
                temp.val = t.val;
                return;
            }
            getKValue(t.right, k, temp);
        
        }
    }

例如，对于下面的树，预期输出为1。但我得到了3，控制台打印了两次0

Input: root = [3,1,4,null,2], k = 1
   3
  / \
 1   4
  \
   2
Output: 1

---

我认为问题是因为在每个递归调用中传递

k

。您不应该这样做，因为这会导致每个递归调用都获得自己的

k

副本。这意味着当您修改

k

时：

k = k - 1;

堆栈中的另一个调用不知道

k

更改。就其他调用而言，

k

仍然是1，因为它们都有自己的副本

要解决此问题，您应该有一个共享的

k

，所有递归调用都可以访问：

    static int sharedK; // shared!
    public int kthSmallest(TreeNode t, int k) {
      TreeNode tempNode = new TreeNode();
      sharedK = k; // setting the sharedK
      getKValue(t, tempNode); 
      return tempNode.val;
    }
    
    private static void getKValue(TreeNode t, TreeNode temp) {
        if(t == null) {
            return;
        }

        getKValue(t.left, temp);
        
        sharedK--; // note the change here
        System.out.println(sharedK);
        if(sharedK == 0) {
            temp.val = t.val;
            return;
        }
        getKValue(t.right, temp);
    }

---

如果

k

通过引用传递，同样可以实现，但不幸的是，在Java中不能通过引用传递。

我认为问题需要您输出BST的第k个最小元素，下面是使用O（N）内存空间的代码，其中N是BST中的节点数。首先，我们将使用顺序遍历（递归）遍历BST，并将节点保存在数组或向量中。按顺序遍历BST以排序的顺序给出节点

struct TreeNode {
    int val;
    TreeNode *left;
    TreeNode *right;
};

vector<int> nodes;

void inorder(TreeNode *root) {
    if(root!=NULL)
    {
        inorder(root->left);
        nodes.push_back(root->val);
        inorder(root->right);
    }
}
class Solution {
public:
    int getValue(TreeNode* root,int K)
    {
        nodes.clear();
        if(root!=NULL)
        {
            inorder(root);
            return nodes[K-1];
        }
        return -1;
    }
};

结构树节点{ int-val； TreeNode*左； TreeNode*对； }; 向量节点； 按顺序无效（树节点*根）{ if（root！=NULL） { 顺序（根->左）； 节点。向后推（root->val）； 顺序（根->右）； } } 类解决方案{ 公众： int getValue（树节点*root，int K） { nodes.clear（）； if（root！=NULL） { 顺序（根）； 返回节点[K-1]； } 返回-1； } };

---

试着在一张纸上调试并跟踪执行，你就会知道为什么会得到3，而0会被打印两次。您递归调用helper函数，然后执行k=k-1，这就是为什么您会看到0被打印两次。最后一次返回将在节点3，这就是为什么3是returned@SherifelKhatib事实并非如此。他被打印了两次，因为每次他调用递归方法时，都会从树的左侧和右侧生成一个新的K副本。他需要发送一个对LHS和RHS都通用的K（即通过引用调用的情况，但不幸的是java不支持通过引用调用）@PapaifromBEKOAIL我的原因是从执行角度，而你的原因是从算法角度。。。同样的