leetcode98_验证二叉搜索树

一.  二叉树的题目感觉不是递归就是动态规划.(注意二叉搜索树的理解,一开始验证的时候题目的意思理解错误了,以为只要左右一层的子树满足就可以了).

#include <iostream>
using namespace std;

struct TreeNode {
    int val;
    TreeNode *left;
	TreeNode *right;
	TreeNode(int x) : val(x), left(NULL), right(NULL) {}
};

class Solution {
public:
	bool isValidBST(TreeNode* root) {
		//边界空树为true.
		if (root == NULL) return true;
		//二叉搜索树的定义是除了满足基本的大小关系.
		//左子树的最大值需要小于根节点值.
		if (root->left != NULL) {
			TreeNode* tmp = root->left;
			while (tmp->right != NULL) {
				tmp = tmp->right;
			}
			if (root->val <= tmp->val) return false;
		}
		//右子树最小值需要大于根节点值.
		if (root->right != NULL) {
			TreeNode* tmp = root->right;
			while (tmp->left != NULL) {
				tmp = tmp->left;
			}
			if (root->val >= tmp->val) return false;
		}
		//递归处理接下来的左右子树.
		bool left = isValidBST(root->left);
		bool right = isValidBST(root->right);
		//只有每一个都满足了才算满足.
		return left&&right;
	}
};

 

二. 按照惯例参考下官方题解

作者：LeetCode
链接：https://leetcode-cn.com/problems/validate-binary-search-tree/solution/yan-zheng-er-cha-sou-suo-shu-by-leetcode/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

1.  问题是，这种方法并不总是正确。不仅右子结点要大于该节点，整个右子树的元素都应该大于该节点。

2.  这意味着我们需要在遍历树的同时保留结点的上界与下界，在比较时不仅比较子结点的值，也要与上下界比较。

方法一: 递归

//官方递归,
//从上到下检查是否符合,
//自顶向下的分治策略.
//所以需要构造一个helper函数.
class Solution {
public:
	bool helper(TreeNode* root, long low, long high) {
		if (root == NULL) return true;
		if (low != LONG_MAX && root->val <= low) return false;
		if (high != LONG_MAX && root->val >= high) return false;
		if (!helper(root->left, low, root->val)) return false;
		if (!helper(root->right, root->val, high)) return false;
		return true;
	}
	bool isValidBST(TreeNode* root) {
		//技巧.
		//将low和high初始化为int取不到的值,并用long.
		return helper(root, LONG_MAX, LONG_MAX);
	}
};

复杂度分析(树的复杂度都可以这么分析)

• 时间复杂度 : O(N)。每个结点访问一次。
• 空间复杂度 : O(N)。我们跟进了整棵树。

 

方法二: 迭代

1.  通过使用栈，上面的递归法可以转化为迭代法。这里使用深度优先搜索，比广度优先搜索要快一些。

2.  直接放上作者的java代码,就不写非递归的实现了.

class Solution {
	LinkedList<TreeNode> stack = new LinkedList();
	LinkedList<Integer> uppers = new LinkedList(),
		lowers = new LinkedList();

	public void update(TreeNode root, Integer lower, Integer upper) {
		stack.add(root);
		lowers.add(lower);
		uppers.add(upper);
	}

	public boolean isValidBST(TreeNode root) {
		Integer lower = null, upper = null, val;
		update(root, lower, upper);

		while (!stack.isEmpty()) {
			root = stack.poll();
			lower = lowers.poll();
			upper = uppers.poll();

			if (root == null) continue;
			val = root.val;
			if (lower != null && val <= lower) return false;
			if (upper != null && val >= upper) return false;
			update(root.right, val, upper);
			update(root.left, lower, val);
		}
		return true;
	}
}

复杂度分析

• 时间复杂度 : O(N)。每个结点访问一次。
• 空间复杂度 : O(N)。我们跟进了整棵树。

 

方法三：中序遍历(二叉搜索树中序遍历一定是有序的,切记!!!!!!!!)

1.  计算中序遍历列表 inorder.

2.  检查 inorder中的每个元素是否小于下一个。

3.  我们需要保留整个inorder列表吗？事实上不需要。每一步最后一个添加的元素就足以保证树是（或不是）二叉搜索树。
因此，我们可以将步骤整合并复用空间。

4. 作者用的非递归的方法,我就用递归的方法重新改写一下.

//中序遍历
class Solution {
public:
	//定义全局变量,用long,防止冲突.
	long maxv = LONG_MIN;
	bool isValidBST(TreeNode* root) {
		if (root == NULL) return true;
		if(!isValidBST(root->left)) return false;
		if (root->val <= maxv) return false;
		maxv = root->val;
		return isValidBST(root->right);
	}
};