剑指offer——面试题63：二叉搜索树的第k个结点

力扣
题目略有不同，力扣中问题是返回第k大的节点值。

1.中序遍历

Python

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def findTargetNode(self, root: Optional[TreeNode], cnt: int) -> int:
        res = []
        self.search(root, cnt, res)
        res.reverse()
        return res[cnt-1]

    def search(self, root, cnt, res): # 右根左遍历二叉搜索树，即可得到降序数组
        if not root:
            return
        self.search(root.left, cnt, res)
        res.append(root.val)
        self.search(root.right, cnt, res)

Java

class Solution {
    public int findTargetNode(TreeNode root, int cnt) {
        List<Integer> valList = new ArrayList<>();
        myInOrder(root, valList);
        return valList.get(valList.size() - cnt);
    }

    public void myInOrder(TreeNode root, List<Integer> valList) {
        if (root == null) {
            return;
        }
        myInOrder(root.left, valList);
        valList.add(root.val);
        myInOrder(root.right, valList);
    }
}

中序遍历逆序 + 剪枝

Python

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def findTargetNode(self, root: Optional[TreeNode], cnt: int) -> int:
        res = []
        self.search(root, cnt, res)
        return res[-1]

    def search(self, root, cnt, res): # 右根左遍历二叉搜索树，即可得到降序数组
        if not root or len(res) == cnt:
            return
        self.search(root.right, cnt, res)
        if len(res) == cnt:
            return
        res.append(root.val)
        self.search(root.left, cnt, res)
        if len(res) == cnt:
            return

Java

class Solution {
    public int findTargetNode(TreeNode root, int cnt) {
        List<Integer> valList = new ArrayList<>();
        myReInOrder(root, valList, cnt);
        return valList.get(valList.size() - 1);
    }

    public void myReInOrder(TreeNode root, List<Integer> valList, int size) {
        if (root == null) {
            return;
        }
        myReInOrder(root.right, valList, size);
        if (valList.size() == size) { // 增加剪枝
            return;
        }
        valList.add(root.val);
        myReInOrder(root.left, valList, size);
    }
}

##Solution1:
20180916重做

/*
struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
    TreeNode(int x) :
            val(x), left(NULL), right(NULL) {
    }
};
*/
class Solution {
public:
    TreeNode* KthNode(TreeNode* pRoot, int k) {
        if(pRoot == NULL || k <= 0)
            return NULL;
        vector<struct TreeNode*> result;
        Pre_travel(pRoot, result);
        if(result.size() < k)
            return NULL;
        return result[k - 1];
    }
    void Pre_travel(struct TreeNode* pRoot, 
                    vector<struct TreeNode*> &res) {
        if (!pRoot)
            return;
        if(pRoot->left)
            Pre_travel(pRoot->left, res);
        res.push_back(pRoot);
        if(pRoot->right)
            Pre_travel(pRoot->right, res);
    }
};

##Solution2:
利用二叉搜索树已经有序的性质，直接用中序遍历，得到第k个点返回即可~~~
注意在写递归时，很容易陷进无限递归中导致栈溢出。故递归结束条件应当明确！

/*
struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
    TreeNode(int x) :
            val(x), left(NULL), right(NULL) {
    }
};
*/
class Solution {
public:
    TreeNode* KthNode(TreeNode* pRoot, int k) {
        if(pRoot == NULL || k <= 0)
            return NULL;
        return Inorder_travel(pRoot, k);
    }

    struct TreeNode* Inorder_travel(struct TreeNode *pRoot, int &k) {
        struct TreeNode *res = NULL;
        if(pRoot->left != NULL)
            res = Inorder_travel(pRoot->left, k);
        if(res == NULL) {
            if(k == 1)
                res = pRoot;
            k--;
        }
        if(res == NULL && pRoot->right != NULL)
            res = Inorder_travel(pRoot->right, k);
        return res;
    }
};