114 lines
2.9 KiB
Markdown
114 lines
2.9 KiB
Markdown
# Leetcode Validate-Binary-Search-Tree
|
|
|
|
#### 2022-07-08 10:36
|
|
|
|
> ##### Algorithms:
|
|
> #algorithm #DFS #DFS_inorder
|
|
> ##### Data structures:
|
|
> #DS #binary_tree #binary_search_tree
|
|
> ##### Difficulty:
|
|
> #coding_problem #difficulty-medium
|
|
> ##### Additional tags:
|
|
> #leetcode #CS_list_need_practicing
|
|
> ##### Revisions:
|
|
> N/A
|
|
|
|
##### Related topics:
|
|
```expander
|
|
tag:#DFS_inorder
|
|
```
|
|
|
|
- [[Leetcode Binary-Tree-Inorder-Traversal]]
|
|
|
|
|
|
##### Links:
|
|
- [Link to problem](https://leetcode.com/problems/validate-binary-search-tree/)
|
|
___
|
|
### Problem
|
|
Given the `root` of a binary tree, _determine if it is a valid binary search tree (BST)_.
|
|
|
|
A **valid BST** is defined as follows:
|
|
|
|
- The left subtree of a node contains only nodes with keys **less than** the node's key.
|
|
- ==The right subtree of a node contains only nodes with keys **greater than** the node's key.==
|
|
- Both the left and right subtrees must also be binary search trees.
|
|
|
|
#### Examples
|
|
|
|
**Example 1:**
|
|
|
|
|
|
|
|
**Input:** root = [2,1,3]
|
|
**Output:** true
|
|
|
|
**Example 2:**
|
|
|
|
|
|
|
|
**Input:** root = [5,1,4,null,null,3,6]
|
|
**Output:** false
|
|
**Explanation:** The root node's value is 5 but its right child's value is 4.
|
|
|
|
#### Constraints
|
|
- The number of nodes in the tree is in the range `[1, 104]`.
|
|
- `-231 <= Node.val <= 231 - 1`
|
|
### Thoughts
|
|
|
|
> [!summary]
|
|
> This is a #DFS #DFS_inorder problem.
|
|
|
|
I have thought a lot of recursion methods, but at last I realized:
|
|
|
|
> [!tip] The feature of BST
|
|
> For a BST, DFS inorder search returns an array of ascending numbers.
|
|
|
|
So, I use a DFS inorder, along with a prev reference pointer to keep track of previous value. to validate, the value of node should always be bigger than prev.
|
|
|
|
See comment for why I use a **reference to pointer.**
|
|
|
|
### Solution
|
|
|
|
```cpp
|
|
/**
|
|
* 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 {
|
|
bool checker(TreeNode *root, int *&prev) {
|
|
// Use reference to pointer here, because the pointer address will change
|
|
// when assigning memory. Also can use pointer to pointer, or initialize the
|
|
// pointer and never change the address ever.
|
|
if (!root) {
|
|
return true;
|
|
}
|
|
if (!checker(root->left, prev)) {
|
|
return false;
|
|
}
|
|
if (prev && root->val <= *prev) {
|
|
return false;
|
|
}
|
|
if (!prev) {
|
|
// prev's address got changed
|
|
prev = new int;
|
|
}
|
|
*prev = root->val;
|
|
return checker(root->right, prev);
|
|
}
|
|
|
|
public:
|
|
bool isValidBST(TreeNode *root) {
|
|
// DFS inorder traversal: valid BST returns a ascending array
|
|
int *prev = nullptr;
|
|
return checker(root, prev);
|
|
}
|
|
};
|
|
``` |