最大二叉树
题目:
最大二叉树定义:
二叉树的根是数组中的最大元素
左子树是通过数组中最大值左边部分构造出的最大二叉树。
右子树是通过数组中最大值右边部分构造出的最大二叉树。
通过给定的数组构建最大二叉树,并且输出这个树的节点。
构造二叉树一般采用的是前序遍历,因为先构造中间节点,然后构造左子树和右子树。
>>确定递归函数的参数和返回值
参数传入的是存放元素的数组,返回该数组构造的二叉树的头节点,返回类型是指向节点的指针。
TreeNode* constructMaximumBinaryTree(vector<int>& nums)
>>确定终止条件
题目中说了输入的数组大小一定是大于等于1的,所以我们不用考虑小于1的情况,那么当递归遍历的时候,如果传入的数组大小为1,说明遍历到了叶子节点了。
那么应该定义一个新的节点,并把这个数组的数值赋给新的节点,然后返回这个节点。这表示一个数组大小是1的时候,构造了一个新的节点,并返回。
TreeNode * node = new TreeNode(0);
if(nums.size()== 1){node->val = nums[0];return node;
}
>>确定单层递归的逻辑
1.找到数组中最大的值和对应的下标,最大的值构造根节点,下标用来下一步分割数组。
2.最大值所在的下标左区间构造左子树,这里要判断maxValueIndex > 0,因为要保证左区间至少有一个数值。
3.最大值所在的下标右区间 构造右子树 ,这里要判断maxValueIndex < (nums.size() - 1),确保右区间至少有一个数值。
class Solution{
public:TreeNode* constructMaximumBinaryTree(vector<int>&nums){TreeNode* node = new TreeNode(0);if(nums.size() == 1){node->val = nums[0];return node;}//找到数组中最大的值和对应的下标int maxValue = 0;int maxValueIndex = 0;for(int i = 0;i < nums.size();i++){if(nums[i] > maxValue){maxValue = nums[i];maxValueIndex = i;}}node->val = maxValue;//最大值所在的下标左区间 构造左子树if(maxValueIndex > 0){vector<int>newVec(nums.begin(),nums.begin() + maxValueIndex);node->left = constructMaximumBinaryTree(newVec);}//最大值所在的下标右区间,构造右子树if(maxValueIndex < (nums.size()-1)){vector<int>newVec(nums.begin() + maxValueIndex + 1,nums.end());node->right = constructMaximumBinaryTree(newVec);}return node;}
};
优化:
class Solution{
public:TreeNode* traversal(vector<int>&nums,int left,int right){if(left >= right)return nullptr;int maxValueIndex = left;for(int i = left + 1;i < rigth;++i){if(nums[i] > nums[maxValueIndex])maxValueIndex = i;}TreeNode* root = new TreeNode(nums[maxValueIndex]);root->right = traversal (nums,maxValueIndex + 1,right);return root;}public:TreeNode* constructMaximumBinaryTree(vector<int>&nums){return traversal(nums,0,nums.size());}
};
加if是为了不让空节点进入递归,这样后面终止条件就不需要加入 遇到空节点,如果不用if,后面终止条件就得加上 遇到空节点。
二叉搜索树中的搜索
题目:给定一个二叉搜索树BST的根节点和一个值。在BST中找到节点值等于给定值的节点。返回该节点作为树的子树。如果不存在,返回,NULL。
二叉搜索树:特点有序
A.若它的左子树不空,则左子树上所有节点的值均小于它的根节点的值;
B.若它的右子树不空,则右子树上所有节点的值均大于它的根节点的值;
C.它的左右子树也为二叉搜索树
本题就是在二叉搜索树中搜索一个节点,看如何遍历。
递归法
1.确定递归函数的参数和返回值
递归函数的参数传入的就是根节点和要搜索的数值,返回的就是以这个搜索数值所在的节点。
代码:
TreeNode* searchBST(TreeNode* root,int val)
2.确定终止条件
如果root为空,或者找到这个数值了,就返回root节点。
if(root == NULL || root -> val == val)return root;
3.确定单层递归的逻辑
因为二叉搜索树的节点是有序的,所以可以有方向的去搜索。
如果root -> val > val,搜索左子树,如果root -> val < val,就搜索右子树,最后如果都没有搜索到,就返回NULL。
代码如下:
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){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){if(root == NULL || root->val == val)return root;if(root->val > val)return searchBST(root->left,val);if(root->val < val)return searchBST(root->right,val);return NULL;}
};
迭代法
由于二叉搜索树的节点具有有序性,可以不使用辅助栈或队列就可以写出迭代法。
对于一般二叉树,递归过程中还有回溯的过程,例如走一个左方向的分支走到头了,那么要掉头,再走右分支。而对于二叉搜索树,不需要回溯,因为节点的有序性会帮我们确定正确的搜索方向。
迭代法代码:
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;}
};
二叉搜索树的特性记牢,利用它的特性写遍历会很简单。
验证二叉搜索树
题目:给定一个二叉树,判断其是否是一个有效的二叉搜索树。
待判定的特征:
1.节点的左子树只包含小于当前节点的数。
2.节点的右子树只包含大于当前节点的数。
3.所有左子树和右子树自身必须也是二叉搜索树。
思路:
要知道中序遍历下,输出的二叉搜索树节点的数值是有序序列。
有了这个特性,验证二叉搜索树,就相当于变成了判断一个序列是不是递增的了。
递归法
可以递归中序遍历将二叉搜索树变成一个数组,代码:
vector<int>vec;
void traversal(TreeNode* root){if(root == NULL)return;traversal(root->left);vec.push_back(root->val);//将二叉搜素树转换为有序数组traversal(root->right);
}
比较一下,看这个数组是否有序,注意:二叉搜索树中不能有重复元素。
traversal(root);
for(int i = 1;i < vec.size();i++){//注意要小于等于,搜索树里不能有相同的元素
if(vec[i] <= vec[i - 1])return false;
}
return true;
完整代码:
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;}
}
上面转化成数组,然后判断是否有序,也可以不转换,直接在遍历中判断是否有序
注意点:是左子树“所有”节点小于中间节点,不是一个,右子树同理
样例中最小节点 可能是int的最小值,如果这样使用最小的int来比较也是不行的。
可以初始化元素为long long的最小值。
如果阳历中根节点的val可能是long long 的最小值呢?
递归三部曲:
>>确定递归函数,返回值以及参数
要定义一个long long 的全局变量,用来比较遍历的节点是否有序,因为后台测试数据中有int最小值,所以定义为long long的类型,初始化为long long 最小值。
注意递归函数要有bool类型的返回值,只有寻找一条边或一个节点的时候,递归函数会有bool类型的返回值,
本题中,我们寻找一个不符合条件的节点,如果没有找到这个节点就遍历了整棵树,而如果找到了不符合的节点,就立刻返回
long long maxVal = LONG_MIN;
bool isValidBST(TreeNode* root)
确定终止条件
二叉搜索树可以为空
if(root == NULL)return true;
确定单层递归的逻辑
中序遍历,一直更新maxVal,一旦发现maxVal >= root->val,就返回false,注意元素相同时候也要返回false.
bool left = isValidBST(root->left);
//中序遍历,验证遍历的元素是不是从小到大
if(maxVal < root->val)maxVal = root->val;
else return false;bool right = isValidBST(root->right);
return left && right;
整体代码如下:
class Solution{
public:long long maxVal = LONG_MIN;bool isValidBST(TreeNode* root){if(root == NULL)return true;bool left = isValid(root->left);if(maxVal < root->val)maxVal = root->val;else return false;bool right = isValidBST(root->right);return left && right; }
};
上面 maxVal用的是long long最小值,原因是后台数据有int最小值测试用例。
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)retrun false;pre = root;//记录前一个节点bool right = isValidBST(root->right);return left && right;}
};
迭代法
迭代法模拟二叉树中序遍历
迭代法中序遍历稍加改动就可以:
class Solution{
public:bool isValidBST(TreeNode* root){stack<TreeNode*>st;TreeNode* cur = root;TreeNode* pre = NULL;//记录前一个节点while(cur != NULL||st.empty()){if(cur != NULL){st.push(cur);sur = cur->left;}else{cur = st.top();st.pop();if(pre != NULL && cur->val <= pre->val)return false;pre = cur;//保存前一个访问的节点cur = cur->right;}}return true;}
};