树相关

目录

LeetCode104.二叉树的最大深度

方法1：递归

方法2：层序遍历

LeetCode 559.N叉树的最大深度

方法1：递归

方法2：层序遍历

剑指offer 55-II 平衡二叉树

方法1：递归

---

LeetCode104.二叉树的最大深度

二叉树的最大深度等于左子树和右子树深度的最大值+1

方法1：递归

采用类似后续遍历的方法，因为要先知道左子树和右子树的深度，才能知道总的高度。

class Solution {
public:
    int maxDepth(TreeNode* root) {
        if(root==NULL)
        {
            return 0;
        }
        int res;
        int leftd=maxDepth(root->left);
        int rightd=maxDepth(root->right);
        res=max(leftd,rightd)+1;
        return res;
    }
};

方法2：层序遍历

class Solution {
public:
    int maxDepth(TreeNode* root) {
        if(root==NULL)    //如果根为空，直接返回0
        return 0;
        int depth=0;      
        queue<TreeNode*> que;   //队列
        que.push(root);    //将根入队
        while(!que.empty())   //当队不是空的时候，新的一层
        {
            int size=que.size();  //该层元素的个数
            depth++;   //层数加1
            for(int i=0;i<size;i++)   //将该层的下一层入队
            {
                TreeNode* node=que.front();  //获得队首元素
                que.pop();  //队首元素出队
                if(node->left)   //如果该元素有左孩子
                    que.push(node->left);  //左孩子入队
                if(node->right)  //如果该元素有右孩子
                    que.push(node->right); //右孩子入队
            }
        }
        return depth;
    }
};

LeetCode 559.N叉树的最大深度

方法1：递归

/*
// Definition for a Node.
class Node {
public:
    int val;
    vector<Node*> children;

    Node() {}

    Node(int _val) {
        val = _val;
    }

    Node(int _val, vector<Node*> _children) {
        val = _val;
        children = _children;
    }
};
*/

class Solution {
public:
    int maxDepth(Node* root) {
        if(root==NULL)  //如果root为空，直接返回0
        {
            return 0;
        }
        int depth=0;   //当前树的子树的最大深度
        for(int i=0;i<root->children.size();i++)
        {
            depth=max(depth,maxDepth(root->children[i]));   //更新当前树的子树的最大深度
        }
        return depth+1; //返回子树深度最大值+1
    }
};

方法2：层序遍历

/*
// Definition for a Node.
class Node {
public:
    int val;
    vector<Node*> children;

    Node() {}

    Node(int _val) {
        val = _val;
    }

    Node(int _val, vector<Node*> _children) {
        val = _val;
        children = _children;
    }
};
*/

class Solution {
public:
    int maxDepth(Node* root) {
        if(root==NULL)   //如果root为空，返回0
            return 0;
        queue<Node*> que;  //队列
        que.push(root);    //将根入队
        int depth=0;       //树的深度
        while(!que.empty())  //到达新的一层
        {
            int size=que.size();  //该层节点的个数
            depth++;   //层数加1
            for(int i=0;i<size;i++)  //将该层节点的孩子入队
            {
                Node* node=que.front();  //获得队首元素
                que.pop(); //队首元素出队
                for(int j=0;j<node->children.size();j++)
                {
                    que.push(node->children[j]);
                }
            }
        }
        return depth; 
    }
};

剑指offer 55-II 平衡二叉树

方法1：递归

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    int depth(TreeNode* root)   //计算以root为根的树的深度
    {
        if(root==NULL)
        {
            return 0;
        }
        int dep=0;
        int left=depth(root->left);
        int right=depth(root->right);
        dep=max(left,right)+1;
        return dep;
    }
    bool isBalanced(TreeNode* root) {
        if(root==NULL)  //如果树为空，直接返回真
        {
            return true;
        }
        int le=depth(root->left);   //le为左子树的高度
        int ri=depth(root->right);  //ri为右子树的高度
        //如果左子树和右子树的高度差小于等于1 并且 左右子树都是平衡树 返回真 否则返回假
        //刚开始忘了左子树和右子树也要都是平衡树的条件
        if(abs(le-ri)<=1 && isBalanced(root->left) && isBalanced(root->right) )  
        {
            return true;
        }
        else return false;
    }
};