算法进阶__第5课（判断一棵二叉树是否是搜索二叉树、判断一棵二叉树是否是完全二叉树、判断一棵树是否是平衡二叉树、二叉树的最大路径和[1][2]、最大欢乐值、）

 

判断一棵二叉树是否是搜索二叉树、

  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]);//不选择当前节点的情况下，可以选择选
//子节点和不选子节点两种情况
            }
        }
    }
    
    
};

给定一个数组，求子数组的最大异或和。
一个数组的异或和为，数组中所有的数异或起来的结果。