判断一棵二叉树是否是搜索二叉树、
struct TreeNode {
int val;
TreeNode *left;
TreeNode *right;
TreeNode(int x) : val(x), left(NULL), right(NULL) {}
};
class Solution1{
public:
long res = LONG_MIN;
bool isValidBST(TreeNode* root) {
return proccess(root);
}
bool proccess(TreeNode* root)
{
if(root == NULL)
{
return true ;
}
if (!proccess(root->left))
return false;
if(root->val > res)
{
res = root->val;
}
else
{
return false;
}
if(!proccess(root->right))
return false;
return true;
}
};
判断一棵二叉树是否是完全二叉树、
class Solution {
public:
queue<TreeNode*> q;
bool leaf = false;
bool isCompleteTree(TreeNode* root)
{
// write your code here
if(root == NULL)
return true;
q.push(root);
while(!q.empty())
{
TreeNode *r = q.front();
q.pop();
/*根据左右子树的情况进行处理
(1)左右子树都不为空 而且没有开启子树 什么也不做
(2)左子树不为空 右子树为空 并且没有开启子树 则开启子树
(3)左右子树为空 开启了子树 什么也不做
(4)左右子树为空 没有开启子树 则开启子树
(5)其他情况都返回false。
*/
if (r->left != NULL && r->right != NULL && leaf == false)
{
// leaf = false;
}//未开启阶段
else if(r->left != NULL && r->right == NULL && leaf == false)
{
leaf = true;
}//开启阶段
else if(r->left == NULL && r->right == NULL &&leaf == false)
{
leaf = true;
}//开启新阶段
else if(r->left == NULL && r->right == NULL &&leaf == true)
{
// leaf = true;
}//新阶段的处理
else
return false;
if(r->left != NULL)
q.push(r->left);
if(r->right != NULL)
q.push(r->right);
}
return true;
}
};
判断一棵树是否是平衡二叉树)
class Solution {
public:
bool res = true;
/**
* @param root: The root of binary tree.
* @return: True if this Binary tree is Balanced, or false.
*/
bool isBalanced(TreeNode * root) {
// write your code here
proccess(root);
return res;
}
int proccess(TreeNode * root)
{
if (root == NULL)
return 0;
int l = proccess(root->left);
int r = proccess(root->right);
int lmax = max(l, r);
int sub = abs(l - r);
if (sub > 1)
{//没有获取高度
res = false;
}
return lmax+1;
}
};
二叉树的最小深度
class Solution {
public:
int mins = INT_MAX;//注意初始值对结果的影响
int minDepth(TreeNode* root) {
if(root == NULL)
return 0;//考虑空树的影响
else
proccess(root,0);
return mins ;
}
void proccess(TreeNode * root, int count)
{
if (root != NULL)
{
if (root->left == NULL && root->right == NULL)//到达叶子节点
{
mins = min(mins, count + 1);
}
proccess(root->left,count +1);
proccess(root->right,count + 1);
}
}
};
按层遍历二叉树
class Solution6 {
public:
queue<TreeNode*> q;
vector<vector<int>> levelOrder(TreeNode* root) {
vector<vector<int>> res;
if(root == NULL)
return res;
q.push(root);
while(!q.empty())
{
vector<int> temp;
int t = q.size();
//进队操作
for (int i = 0; i < t; i++)
{
TreeNode *r = q.front();
q.pop();
temp.push_back(r->val);
if(r->left != NULL)
q.push(r->left);
if(r->right != NULL)
q.push(r->right);
}//开启一个阶段
res.push_back(temp);
}
return res;
}
};
树的每一层的平均值
class Solution8 {
public:
queue<TreeNode *> q;
vector<double> averageOfLevels(TreeNode* root) {
vector<double> res;
if(root == NULL)
return res;
q.push(root);
while(!q.empty())
{
int t = q.size();
double sum = 0;//注意相加和的最大值
for (int i = 0; i < t; i++)
{
TreeNode *r = q.front();
q.pop();
sum +=r->val;
if(r->left != NULL)
q.push(r->left);
if(r->right != NULL)
q.push(r->right);
}//开启一个阶段
res.push_back(sum/(t*1.0));
}
return res;
}
};
求二叉树的节点个数
class Solution9 {
public:
queue<TreeNode *> q;
int countNodes(TreeNode* root) {
int res = 0;
if(root == NULL)
return 0;
q.push(root);
while(!q.empty())
{
int t = q.size();
double sum = 0;//注意相加和的最大值
for (int i = 0; i < t; i++)
{
TreeNode *r = q.front();
q.pop();
res++;
if(r->left != NULL)
q.push(r->left);
if(r->right != NULL)
q.push(r->right);
}//开启一个阶段
}
return res;
}
};
求二叉树的最长路径
class Solution {
public:
int maxs = 0;
int diameterOfBinaryTree(TreeNode* root) {
proccess(root);
return maxs;
}
int proccess(TreeNode * root)
{
if (root == NULL)
return 0;
int l = proccess(root->left);
int r = proccess(root->right);
maxs = max(maxs , l + r);//这里定义的路径长度是节点数目减去1
return max(l,r) + 1 ;
}
};
二叉树中的最大路径和1
给出一棵二叉树,寻找一条路径使其路径和最大,路径可以在任一节点中开始和结束(路径和为两个节点之间所在路径上的节点权值之和)
样例
样例 1:
输入: 给定一棵树(只有一个节点):
2
输出:2
样例 2:
输入: 给定一棵树:
1
/ \
2 3
输出: 6
class retData
{
public:
int maxval;
int lrmaxval;
retData(int max, int lrmax)
{
maxval = max;//当前最长路径
lrmaxval = lrmax;
}//返回值
};
class Solution {
public:
/**
* @param root: The root of binary tree.
* @return: An integer
*/
retData proccess(TreeNode *root)
{
if(root == NULL)
{
return retData(-65535,-65535);
}
retData l = proccess(root->left);
retData r = proccess(root->right);
int maxs = root->val;
if (l.lrmaxval > 0) {
maxs +=l.lrmaxval;
}
if (r.lrmaxval > 0) {
maxs +=r.lrmaxval;
}
int tmax = max(max(l.maxval, r.maxval), maxs);
return retData(tmax, max(0,max(l.lrmaxval, r.lrmaxval)) + root->val);
}
int maxPathSum(TreeNode * root) {
// write your code here
return (proccess(root)).maxval;
}
};
二叉树的最大路径和2
class Solution {
public:
int maxs = 0;
int diameterOfBinaryTree(TreeNode* root) {
proccess(root);
return maxs;
}
int proccess(TreeNode * root)
{
if (root == NULL)
return 0;
int l = proccess(root->left);
int r = proccess(root->right);
maxs = max(maxs , l + r);//这里定义的路径长度是节点数目减去1
return max(l,r) + 1 ;
}
};
一个公司的上下节关系是一棵多叉树,这个公司要举办晚会,你作为组织者已经摸清了大家的心理:一个员工的直
接上级如果到场,这个员工肯定不会来。每个员工都有一个活跃度的值,决定谁来你会给这个员工发邀请函,怎么
让舞会的气氛最活跃?返回最大的活跃值。
举例:
给定一个矩阵来表述这种关系
matrix =
{
1,6
1,5
1,4 }
这个矩阵的含义是:
matrix[0] = {1 , 6},表示0这个员工的直接上级为1,0这个员工自己的活跃度为6
matrix[1] = {1 , 5},表示1这个员工的直接上级为1(他自己是这个公司的最大boss),1这个员工自己的活跃度 为5
matrix[2] = {1 , 4},表示2这个员工的直接上级为1,2这个员工自己的活跃度为4
class Solution
{
public:
int dp[1000][2] ={0} ;
bool visited[1000];
int maxHappy(vector<vector<int>> matrix)//m[0] ={1,6}表示的是0号员工的直属上级是1 活跃
//度是6
{
//找到最大的领导
int root = 0;
for (int i = 0; i < matrix.size(); i++) {
if (i == matrix[i][0]) {
root = i;
break;
}
}
proccess(matrix, root);
return max(dp[root][0], dp[root][1]);
}
void proccess(vector<vector<int>> matrix, int root)
{
visited[root] = true;
dp[root][1] = matrix[root][1];//保存选择当前节点的活跃度
for (int i = 0; i < matrix.size(); i++) {
if (matrix[i][0] == root && visited[i] == false) {
proccess(matrix, i);//访问i的子节点,
dp[root][1] +=dp[i][0];//选择当前节点 不选择子节点的活跃度
dp[root][0] += max(dp[i][0], dp[i][1]);//不选择当前节点的情况下,可以选择选
//子节点和不选子节点两种情况
}
}
}
};
给定一个数组,求子数组的最大异或和。
一个数组的异或和为,数组中所有的数异或起来的结果。