C++ 解法, 执行用时: 2ms, 内存消耗: 408KB, 提交时间: 2021-11-25

/**
 * struct TreeNode {
 *	int val;
 *	struct TreeNode *left;
 *	struct TreeNode *right;
 *	TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 * };
 */
class Solution {
public:
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param proot TreeNode类 
     * @param k int整型 
     * @return int整型
     */
    int n=0;
    int findret(TreeNode* proot, int k, vector<int> &v){
        if(proot == NULL){
            return -1;
        }
        n=n+1;
        v.push_back(proot->val);
        printf("%d ",n);
        findret(proot->left,k,v);
        findret(proot->right,k,v);
        return 0;
    }
    int KthNode(TreeNode* proot, int k) {
        if(proot == NULL || k == 0){
            return -1;
        }
        
        // write code here 
        if(proot->left == NULL && proot->right == NULL){
            if(k == 1){
                return proot->val;
            }
        }
        vector<int> v;
        findret(proot,k,v);
        sort(v.begin(), v.end());
        if(k > n){
                return -1;
        }
        return v[k-1];
    }
};

C++ 解法, 执行用时: 2ms, 内存消耗: 432KB, 提交时间: 2022-02-10

class Solution
{
public:
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     *
     * @param proot TreeNode类
     * @param k int整型
     * @return int整型
     */
    int KthNode(TreeNode *proot, int k)
    {
        if (proot == nullptr || k <= 0)
            return -1;
        KthNode(proot->left, k);
        ++count;
        if (k == count)
            return ret = proot->val;
        KthNode(proot->right, k);
        return ret;
    }
    private:
    int ret = -1;
    int count = 0;
};

C++ 解法, 执行用时: 2ms, 内存消耗: 472KB, 提交时间: 2021-11-29

/**
 * struct TreeNode {
 *	int val;
 *	struct TreeNode *left;
 *	struct TreeNode *right;
 *	TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 * };
 */
class Solution {
public:
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param proot TreeNode类 
     * @param k int整型 
     * @return int整型
     */
     vector<int> array;
    int KthNode(TreeNode* proot, int k) {
        // write code here
       if(!proot||k==0) return -1;
       inOrder(proot);
       if(k>array.size())  return -1;
       return array[k-1];
    }
     void inOrder( TreeNode* proot) //中序遍历
	{
		if ( proot == NULL) return;
		inOrder(proot->left);
		array.push_back(proot->val);
		inOrder(proot->right);
	}
};

C++ 解法, 执行用时: 2ms, 内存消耗: 564KB, 提交时间: 2021-11-29

/**
 * struct TreeNode {
 *	int val;
 *	struct TreeNode *left;
 *	struct TreeNode *right;
 *	TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 * };
 */
class Solution {
public:
    vector<TreeNode*> list;
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param proot TreeNode类 
     * @param k int整型 
     * @return int整型
     */
    void addList(TreeNode* root){
        if(!root) return;
        if(list.size() == 0){
            list.push_back(root);
        }
        else{
            auto it = list.begin();
            while(it != list.end() && (*it)->val < root->val){
                it++;
            }
            list.insert(it, root);
        }
        addList(root->left);
        addList(root->right);
    }
    
    int KthNode(TreeNode* proot, int k) {
        // write code here
        if(k == 0) return -1;
        addList(proot);
        return list.size() >= k ? list[k - 1]->val : -1;
    }
};

Go 解法, 执行用时: 2ms, 内存消耗: 1012KB, 提交时间: 2022-01-27

package main
import . "nc_tools"
/*
 * type TreeNode struct {
 *   Val int
 *   Left *TreeNode
 *   Right *TreeNode
 * }
 */

/**
 * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
 *
 * 
 * @param proot TreeNode类 
 * @param k int整型 
 * @return int整型
*/
func KthNode( proot *TreeNode ,  k int ) int {
    // write code here
    if proot == nil || k == 0 {
        return -1
    }
    
    nodeList := make([]*TreeNode, 0)
    
    var inorder func(node *TreeNode)
    inorder = func(node *TreeNode) {
        if node == nil {
            return
        }
        
        inorder(node.Left)
        nodeList = append(nodeList, node)
        inorder(node.Right)
    }
    
    inorder(proot)

    if len(nodeList) < k {
        return -1
    }
    
    return nodeList[k-1].Val
}