103、【树与二叉树】leetcode ——700. 二叉搜索树中的搜索：递归法+迭代法（C++/Python版本）-CSDN博客

本文链接：https://blog.csdn.net/qq_41094332/article/details/128708964

题目描述

解题思路

根据BST的特性，左子树比根节点小，右子树比根节点大。向对应方向遍历

1、递归法

先序遍历

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    TreeNode* searchBST(TreeNode* root, int val) {
        if(!root || root->val == val)       return root;        // 返回NULL或root;

        TreeNode* node = NULL;
        if(val < root->val)    node = searchBST(root->left, val);
        if(val > root->val)    node = searchBST(root->right, val);
        return node;
    }
};

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 searchBST(self, root: Optional[TreeNode], val: int) -> Optional[TreeNode]:
        if not root or root.val == val:
            return root
        if val < root.val:
            return self.searchBST(root.left, val)
        if val > root.val:
            return self.searchBST(root.right, val)

2、迭代法

先序遍历
C++

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    TreeNode* searchBST(TreeNode* root, int val) {
        stack<TreeNode*> st;
        st.push(root);
        while(!st.empty()) {
            TreeNode* node = st.top();      st.pop();
            if(node->val == val)        return node;
            else if(node->val > val && node->left)    st.push(node->left);
            else if(node->val < val && node->right)   st.push(node->right);
        }
        return NULL;
    }
};

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 searchBST(self, root: Optional[TreeNode], val: int) -> Optional[TreeNode]:
        st = [root]
        while st:
            node = st.pop()            
            if node.val == val:
                return node
            elif val < node.val and node.left:
                st.append(node.left)                
            elif val > node.val and node.right:
                st.append(node.right)   
        return None

层次遍历
C++

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    TreeNode* searchBST(TreeNode* root, int val) {
        queue<TreeNode*> que;
        que.push(root);
        while(!que.empty()) {
            TreeNode* node = que.front();     que.pop();
            if(val == node->val)        return node;
            else if(val < node->val && node->left)      que.push(node->left);
            else if(val > node->val && node->right)     que.push(node->right);
        }
        return NULL;
    }
};

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 searchBST(self, root: Optional[TreeNode], val: int) -> Optional[TreeNode]:
        st = [root]
        while st:
            node = st.pop(0)            // 与先序的区别在于，先序模拟的是栈弹出站定元素也就是列表的尾端元素，层次模拟的是队列弹出队首元素也就是列表的第一个元素
            if node.val == val:
                return node
            elif val < node.val and node.left:
                st.append(node.left)                
            elif val > node.val and node.right:
                st.append(node.right)   
        return None