代码随想录算法训练营第二十天|654.最大二叉树 617.合并二叉树 700.二叉搜索树中的搜索 98.验证二叉搜索

目录

LeeCode 654.最大二叉树

LeeCode 617.合并二叉树

LeeCode 700.二叉搜索树中的搜索

LeeCode 98.验证二叉搜索树

---

LeeCode 654.最大二叉树

654. 最大二叉树 - 力扣（LeetCode）

思路：找到数组中的最大值和对应下标，最大值作为根节点，下标用来分割数组。对分割后的数组再次进行上述操作，直至数组中只有一个元素为止。

class Solution {
public:
    TreeNode* constructMaximumBinaryTree(vector<int>& nums) {
    	return traversal(nums, 0, nums.size());
    }
private:
	TreeNode* traversal(vector<int>& nums, int left, int right) {
		if (left >= right) return NULL;
    	int maxValueIndex = left;
    	for (int i = left + 1; i < right; i++) {
    		if (nums[i] > nums[maxValueIndex])  maxValueIndex = i;
		}
		TreeNode* root = new TreeNode(nums[maxValueIndex]);
		root->left = traversal(nums, left, maxValueIndex);
		root->right = traversal(nums, maxValueIndex + 1, right);
		return root;
	}
};

---

LeeCode 617.合并二叉树

617. 合并二叉树 - 力扣（LeetCode）

思路：遍历两棵树，并将相同位置节点的值相加。

class Solution {
public:
    TreeNode* mergeTrees(TreeNode* root1, TreeNode* root2) {
    	if (t1 == NULL) return t2;
    	if (t2 == NULL) return t1;
    	t1->val += t2->val;
    	t1->left = mergeTrees(t1->left, t2->left);
    	t1->right = mergeTrees(t1->right, t2->right);
    	return t1;
    }
};

---

LeeCode 700.二叉搜索树中的搜索

700. 二叉搜索树中的搜索 - 力扣（LeetCode）

思路：BST树有序，故搜索时若root->val > val，搜索左子树，若root->val < val，搜索右子树，如果都没有搜索到，返回NULL。

递归法：

class Solution {
public:
    TreeNode* searchBST(TreeNode* root, int val) {
    	if (root == NULL || root->val == val) return root;
    	TreeNode* result = NULL;
    	if (root->val > val) result = searchBST(root->left, val);
    	if (root->val < val) result = searchBST(root->right, val);
    	return result;
    }
};

迭代法：

class Solution {
public:
    TreeNode* searchBST(TreeNode* root, int val) {
    	while (root != NULL) {
    		if (root->val > val) root = root->left;
    		else if (root->val < val) root = root->right;
    		else return root;
		}
		return NULL;
    }
};

---

LeeCode 98.验证二叉搜索树

98. 验证二叉搜索树 - 力扣（LeetCode）

思路1：递归中序遍历将BST转换为一个数组，验证数组是否有序。

class Solution {
private:
	vector<int> vec;
	void traversal(TreeNode* root) {
		if (root == NULL) return;
		traversal(root->left);
		vec.push_back(root->val);
		traversal(root->right);
	}
public:
    bool isValidBST(TreeNode* root) {
    	vec.clear();
    	traversal(root);
    	for (int i = 1; i < vec.size(); i++) {
    		if (vec[i] <= vec[i - 1])  return false;
		}
		return true;
    }
};

思路2：在递归遍历过程中直接判断是否有序，保证左子树所有节点小于中间节点，右子树所有节点大于中间节点。

class Solution {
public:
	TreeNode* pre = NULL;
    bool isValidBST(TreeNode* root) {
    	if (root == NULL) return true;
    	bool left = isValidBST(root->left);
    	if (pre != NULL && pre->val >= root->val)  return false;
    	pre = root;
    	bool right = isValidBST(root->right);
    	return left && right;
    }
};