力扣数据结构14天学习计划—day11

力扣102

力扣102—二叉树的层序遍历

题意

解题思路—利用队列实现层序遍历

这题老面孔了 ,直接上代码吧。

class Solution 
{
public:
    vector<vector<int>> levelOrder(TreeNode* root) 
    {
        if(nullptr==root)
            return {};
        queue<TreeNode*> que;
        que.push(root);
        vector<vector<int>>res;
        while(!que.empty())
        {
            int num=que.size(); //当前层有多少个节点
            vector<int>tmp; //存放当前层的遍历结果
            for(int n=0;n<num;n++)
            {
                TreeNode* node=que.front();
                que.pop();
                tmp.emplace_back(node->val);
                if(node->left)
                    que.push(node->left);
                if(node->right)
                    que.push(node->right);
            }
            res.emplace_back(tmp);
        }
        return res;
    }
};

力扣104—二叉树的最大深度

力扣104

题意

 

法1—深度优先搜索（递归）

class Solution 
{
public:
    int get_depth(TreeNode* root)
    {
        if(nullptr==root)
            return 0;
        int left_depth=get_depth(root->left);
        int right_depth=get_depth(root->right);
        return 1+max(left_depth,right_depth);
    }
    int maxDepth(TreeNode* root) 
    {
        if(nullptr==root)
            return 0;
        int left_depth=get_depth(root->left);
        int right_depth=get_depth(root->right);
        return 1+max(left_depth,right_depth);  
    }
};

 法2—广度优先搜索（利用队列，非递归）

class Solution 
{
public:
    int get_depth(TreeNode* root)
    {
        if(nullptr==root)
            return 0;
        int left_depth=get_depth(root->left);
        int right_depth=get_depth(root->right);
        return 1+max(left_depth,right_depth);
    }
    int maxDepth(TreeNode* root) 
    {
        if(nullptr==root)
            return 0;
        
        /*
        法1：深度优先搜索
        int left_depth=get_depth(root->left);
        int right_depth=get_depth(root->right);
        return 1+max(left_depth,right_depth);  
        */

        //法2，广度优先搜索
        queue<TreeNode*>que;
        int res=0;
        que.push(root);
        while(!que.empty())
        {
            int num=que.size();
            while(num--)
            {
                TreeNode* node=que.front();
                que.pop();
                if(node->left)
                    que.push(node->left);
                if(node->right)
                    que.push(node->right);
            }
            res++;
        }
        return res;
    }
};

力扣101—对称二叉树

力扣101

题意

 

 

解法1—递归

class Solution 
{
public:
    bool compare(TreeNode* left,TreeNode* right)
    {
        if(nullptr==left&&nullptr!=right)
            return false;
        else if(nullptr!=left&&nullptr==right)
            return false;
        else if(nullptr==left&&nullptr==right)
            return true;
        else if(left->val!=right->val)
            return false;
        bool outside=compare(left->left,right->right);
        bool in=compare(left->right,right->left);
        return outside∈
        
    }
    bool isSymmetric(TreeNode* root) 
    {
        if(root==NULL)
            return true;
        return compare(root->left,root->right);
    }
};

 法2—迭代（利用队列）

class Solution 
{
public:
    bool compare(TreeNode* left,TreeNode* right)
    {
        if(nullptr==left&&nullptr!=right)
            return false;
        else if(nullptr!=left&&nullptr==right)
            return false;
        else if(nullptr==left&&nullptr==right)
            return true;
        else if(left->val!=right->val)
            return false;
        bool outside=compare(left->left,right->right);
        bool in=compare(left->right,right->left);
        return outside∈
        
    }
    bool isSymmetric(TreeNode* root) 
    {
        if(root==NULL)
            return true;
        // return compare(root->left,root->right);
        queue<TreeNode*>que;
        que.push(root->left);
        que.push(root->right);
        while(!que.empty())
        {
            TreeNode* left_node=que.front();
            que.pop();

            TreeNode* right_node=que.front();
            que.pop();

            if(left_node==nullptr&&right_node!=nullptr)
                return false;
            else if(left_node!=nullptr&&right_node==nullptr)
                return false;
            else if(nullptr==left_node&&nullptr==right_node)
                continue;
            else if(left_node->val!=right_node->val)
                return false;
            
            que.push(left_node->left);
            que.push(right_node->right);

            que.push(left_node->right);
            que.push(right_node->left);
        }
        return true;
    }
};