700. 二叉搜索树中的搜索

700. 二叉搜索树中的搜索
     已解答
     给定二叉搜索树（BST）的根节点 root 和一个整数值 val。

你需要在 BST 中找到节点值等于 val 的节点。 返回以该节点为根的子树。 如果节点不存在，则返回 null 。

示例 1:

输入：root = [4,2,7,1,3], val = 2
输出：[2,1,3]
示例 2:

输入：root = [4,2,7,1,3], val = 5
输出：[]

提示：

树中节点数在 [1, 5000] 范围内
1 <= Node.val <= 107
root 是二叉搜索树
1 <= val <= 107

#include <complex>
#include <iostream>
#include<iterator>
#include <vector>
#include <fstream>
#include <string>

using namespace std;


 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 == nullptr)
             return nullptr; //如果根节点为空，返回空子树
         if (root->val == val) //如果根节点的值等于val,返回根节点
             return root;
        
         if (root->val > val) //如果根节点的值大于val
             //若它存在左节点，寻找它左边的子树里有没有符合条件的节点
             if (root->left)
                 return searchBST(root->left, val); //注意这里前面需要return
             else return nullptr;
         if (root->val < val) //如果根节点的值小于val
             //若它存在右节点，寻找它右边的子树里有没有符合条件的节点
             if (root->right)
                 return searchBST(root->right, val);
             else return nullptr;
        return nullptr; //最慢：遍历的节点是它的最大深度，最快，遍历的节点是它的最小深度
     }
 };

int main() //这里的自测主函数为模板，可以自己更换名字和值
{
    Solution solution;

    TreeNode nodes[7];

	nodes[0].val = 1;
    nodes[0].left = &nodes[1];
    nodes[0].right = &nodes[2];

    nodes[1].val = 2;
    nodes[1].left = &nodes[3];
    nodes[1].right = nullptr;

    nodes[2].val = 2;
    nodes[2].left = nullptr;
    nodes[2].right = &nodes[4];

    nodes[3].val = 3;
    nodes[3].left = &nodes[5];
    nodes[3].right = nullptr;

    nodes[4].val = 3;
    nodes[4].left = nullptr;
    nodes[4].right = &nodes[6];

    nodes[5].val = 4;
    nodes[5].left = nullptr;
    nodes[5].right = nullptr;

    nodes[6].val = 4;
    nodes[6].left = nullptr;
    nodes[6].right = nullptr;

    int x = solution.diameterOfBinaryTree(&nodes[0]);

    //vector<int> a = solution.inorderTraversal(nums);
}