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

题目：654.最大二叉树 

文章链接：代码随想录

视频链接：LeetCode:654.最大二叉树

题目链接：力扣题目链接

解法1：

class Solution {
public:
    TreeNode* constructMaximumBinaryTree(vector<int>& nums) {
         // 确定终止条件  如果数组为1则说明是叶子节点
         if(nums.size() == 1){
             TreeNode* node = new TreeNode(nums[0]);
             return node;
         }
         // 前序遍历 中左右
         // 找到数组中的最大值，取它的下标用来分割数组
         int maxnum = 0;
         int Index = 0;
         for(int i=0; i<nums.size(); i++){
              if(nums[i]>maxnum){
                  maxnum = nums[i];
                  Index = i;
              }
         }
         // 新创建一个二叉树，把根节点放入
         TreeNode* node = new TreeNode(nums[Index]); 
         // 分割数组
         // 如果左边元素小于1就不进行分割 左闭右开 [0, Index)
         if(Index>0){
            vector<int>leftnums(nums.begin(),nums.begin()+Index);
             node->left = constructMaximumBinaryTree(leftnums);
         }
         if(Index<nums.size()-1){
            vector<int>rightnums(nums.begin()+Index+1, nums.end());
             node->right = constructMaximumBinaryTree(rightnums);
         }
         return node;     
    }
};

解法2：下标索引法

class Solution {
public:

// 最大二叉树(利用下标进行划分)
TreeNode* terversal(vector<int>& nums,int left,int right) {
	// 给定一个数组返回根节点
	// 判断数组是否为空，为空则返回空指针
	if (left >= right) return NULL;
	//else(nums.size() == 1)
	// 遍历寻找数组的最大值
	int maxindex = left;
	for (int i=left+1; i < right; i++) {
		if (nums[i] > nums[maxindex]) {
			// 更新
			maxindex = i;
		}
	}
	// 创建根节点
	TreeNode *root = new TreeNode(nums[maxindex]);
	// 划分数组，左右遍历  [0,maxindex)
	root->left = terversal(nums,left ,maxindex);
	// [manindex+1,end)
	root->right = terversal(nums,maxindex+1,right);
	return root;
}

    // 最大二叉树
TreeNode* constructMaximumBinaryTree(vector<int>& nums) {
	  return terversal(nums, 0, nums.size());
    }
};

题目：617.合并二叉树

 文章链接：代码随想录

视频链接：LeetCode:617.合并二叉树

题目链接：力扣题目链接

解法1：

class Solution {
public:
    TreeNode* mergeTrees(TreeNode* root1, TreeNode* root2) {
        // 确定终止条件
        if(!root1) return root2; // 当1为空时，返回2，如果2也为空，则同样返回空
        if(!root2) return root1;
        // 前序遍历 (1、2都有)
        root1->val += root2->val;  // 中
        root1->left = mergeTrees(root1->left, root2->left); // 左
        root1->right = mergeTrees(root1->right, root2->right); // 右
        return root1; // 因为是在1上面修改的，所以直接返回1
    }
};

解法2：新建一个二叉树

class Solution {
public:
    TreeNode* mergeTrees(TreeNode* root1, TreeNode* root2) {
        // 确定终止条件
        if(!root1) return root2; // 当1为空时，返回2，如果2也为空，则同样返回空
        if(!root2) return root1;
        // 前序遍历 (1、2都有)
        TreeNode* root = new TreeNode(root1->val + root2->val); // 中
        root->left = mergeTrees(root1->left, root2->left);
        root->right = mergeTrees(root1->right, root2->right);
        return root;
    }
};

解法3：迭代法

//  合并二叉树
TreeNode* mergeTrees(TreeNode* root1, TreeNode* root2) {
	// 迭代法
	queue<TreeNode*>que;
	if (!root1) return root2;
	if (!root2)return root1;
	// 为了保证que对列一开始是成对输入
	que.push(root1);
	que.push(root2);
	while (!que.empty()) {
		TreeNode* node1 = que.front(); que.pop();
		TreeNode* node2 = que.front(); que.pop();
		// 当两数都存在时，赋值给1
		node1->val += node2->val;
		// 
		if (node1->left != NULL&&node2->left != NULL) {
			que.push(node1->left);
			que.push(node2->left);
		} 
		if (node1->right != NULL&&node2->right != NULL) {
			que.push(node1->right);
			que.push(node2->right);
		}
		if (node1->left == NULL&&node2->left != NULL) {
			node1->left = node2->left;
		}
		if (node1->right == NULL&&node2->right != NULL) {
		    node1->right = node2->right ;
		}
	}
	return root1;
}

题目：700.二叉搜索树中的搜索

 文章链接：代码随想录

视频链接：LeetCode:700.二叉搜索树中的搜索

题目链接：力扣题目链接

二叉搜索树：

1. 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值；
2. 若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值；
3. 它的左、右子树也分别为二叉搜索树

解法1：递归法

class Solution {
public:
  // 二叉搜索树中的搜索
TreeNode* searchBST(TreeNode* root, int val) {
	// 终止条件，如果当前节点为空，则说明遍历到底部了还是没有找到
	if (root == NULL) return NULL;
	// 后序 如果满足条件的话，就只会在那一边
	if (root->val > val) {
		return searchBST(root->left, val);
	}
	else if(root->val < val) {
		return searchBST(root->right, val);
	}
	else {
		return root;
	}
}
};

解法2：迭代法

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;
    }
};

题目：98.验证二叉搜索树

 文章链接：代码随想录

视频链接：LeetCode:98.验证二叉搜索

题目链接：力扣题目链接

不能单纯地比较左右节点与当前节点的值，还需要考虑下面节点与当前节点的值

解法1：二叉搜索树的中序是递增的有序数组

递归，遍历二叉树中的所有节点元素，放入数组中，再验证数组是否是有序数组

class Solution {
public:
    vector<int> vec;
    void traversal(TreeNode* node){
       if(node==NULL) return ;
       // 中序遍历二叉树中的每一个节点，将其存放进数组中
       traversal(node->left);
       vec.push_back(node->val);
       traversal(node->right);
       return;
    }

    bool isValidBST(TreeNode* root) {
        vec.clear(); //
        traversal(root);
        for(int i=0; i<vec.size()-1; i++){
            if(vec[i]>=vec[i+1]) return false;
        }
        return true;
    }
};

解法2：双指针遍历

class Solution {
public:
    TreeNode* preNode = NULL;
    bool isValidBST(TreeNode* root) {
        if(root==NULL) return true; //能遍历到后面说明没有不符合的
        // 中序
        bool left = isValidBST(root->left);  // 左
        if(preNode!=NULL && root->val <= preNode->val){  // 中
            return false;
        } 
        preNode = root;  // 记录前一个节点 
        bool right = isValidBST(root->right);
        return left && right;
    }
};