广度优先搜索实例讲解

最新推荐文章于 2024-08-01 23:45:28 发布

qwe954443563

最新推荐文章于 2024-08-01 23:45:28 发布

阅读量307

点赞数

分类专栏：算法专题

本文链接：https://blog.csdn.net/qwe954443563/article/details/111200964

版权

算法专题专栏收录该内容

18 篇文章 0 订阅

订阅专栏

本文详细介绍了LeetCode中三道关于二叉树的题目，分别是判断二叉树是否对称、锯齿形层次遍历以及求最小深度。在每道题目的解决方案中，强调了关键点，如使用队列进行层次遍历，用LONG_MAX代替NULL值，以及根据层次和方向存储节点值。通过这些技巧，可以有效地解决二叉树相关问题。

摘要由CSDN通过智能技术生成

1. 力扣101题
c++代码如下：

/**
 * 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:
    bool isSymmetric(TreeNode* root) {
        if(!root)
            return true;
        queue<TreeNode*>q1;
        q1.push(root);
        while(!q1.empty())
        {
            int size = q1.size();
            vector<int>v(size);
            for(int i=0;i<size;i++)
            {
                TreeNode* cur = q1.front();
                q1.pop();
                v[i]=cur?cur->val:LONG_MAX;
            if(cur)
            {
                q1.push(cur->left);
                q1.push(cur->right);
            }
            }
            for(int i=0;i<size/2;i++)
            {
                if(v[i]!=v[size-i-1])
                    return false;
            }
        }
        return true;
    }
};

这一题注意点有：
（1）当结点地址为空时，仍然可以压入，即可以q.push(NULL)；
（2）当树中有NULL时，可以采用LONG_MAX进行替代因为int数据取不了LONG_MAX值。

2. 力扣103题

/**
 * 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:
    vector<vector<int>> zigzagLevelOrder(TreeNode* root)
    {
        if(!root)
            return {};
        queue<TreeNode*>q;
        vector<vector<int>>res;
        q.push(root);
        int level = 1;
        while(!q.empty())
        {
            int size = q.size();
            vector<int>v(size);
            deque<int>d;
            for(int i=0;i<size;i++)
            {
                TreeNode* cur = q.front();
                if(level%2==0)
                {
                    d.push_front(cur->val);
                }
                else
                    d.push_back(cur->val);
                q.pop();
                v[i]=cur->val;
                if(cur->left)
                    q.push(cur->left);
                if(cur->right)
                    q.push(cur->right);
            }
            res.push_back(vector<int>(d.begin(),d.end()));
            level++;
        }
        return res;

    }
};

注意点：
（1）当结果需要反向输出时，只需要将结果res变换一下即可，不用将队列中的顺序进行变换。
（2）deque可以双向存储，deque.push_back();deque.push_front();
也可以双向弹出，
deque.pop_back();deque.pop_front();
（3）对于迭代器，可以vector(d.begin(),d.end())；

3. 力扣111题

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    int minDepth(TreeNode* root) {
        if(!root)
        return 0;
        int length = 0;
        queue<TreeNode*>q;
        q.push(root);
        int flag = 0;
        
        while(!q.empty())
        {
            
            int size = q.size();
            for(int i=0;i<size;i++)
            {
            TreeNode* cur = q.front();
            q.pop();
            if(cur->left)
                q.push(cur->left);
            if(cur->right)
                q.push(cur->right);
            if(!cur->left && !cur->right)
            {
                flag=1;
                break;
            }
            }
            length++;
            if(flag==1)
                break;
            
        }
        return length;
    }
};