二叉树层序遍历

我这个小垃圾，按照模板做，感觉真不错   举一反三，天天都有着感觉就好，随缘刷题，哪天想起就哪天刷，真的太容易忘记了。

leetcode 102  二叉树的层序遍历

class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        queue<TreeNode*>que;
        if(root!=nullptr)
        que.push(root);
        vector<vector<int>>result;
        while(!que.empty())
        {
            int size=que.size();
            vector<int>vec;
            for(int i=0;i<size;++i)
            {
                TreeNode* node=que.front();
                que.pop();
                vec.push_back(node->val);
                if(node->left)
                que.push(node->left);
                if(node->right)
                que.push(node->right);
            }
            result.push_back(vec);
        }
        return result;
    }
};

leetcode 107 二叉树的层序遍历2

class Solution {
public:
    vector<vector<int>> levelOrderBottom(TreeNode* root) {
        queue<TreeNode*>que;
        if(root!=nullptr)
        que.push(root);
        vector<vector<int>>result;//结果数组
        while(!que.empty())
        {
            vector<int>vec;
            int size=que.size();//因为que的size是不断变化的
            for(int i=0;i<size;++i)
            {
                //层序遍历，我们先定义一个指针，指向que的头
                TreeNode*node=que.front();
                //头节点出队列
                que.pop();
                //将头节点的值存入vec
                vec.push_back(node->val);
                //然后查找头节点的左右孩子，依次入队列
                if(node->left)
                que.push(node->left);
                if(node->right)
                que.push(node->right);
            }
            //将存储值的数组存入结果数组
            result.push_back(vec);
        }
        //题目要求自底向上,我们可以用reverse把result翻转
        reverse(result.begin(),result.end());
        return result;
    }
};

leetcode 199 二叉树的右视图

class Solution {
public:
    vector<int> rightSideView(TreeNode* root) {
        //使用层序遍历，右侧的元素就是最后一个元素，所以我们只需要再基础的层序遍历上判断，这是否是这一层的最后一个元素，将他放入结果数组
        queue<TreeNode*>que;
        if(root!=nullptr)
        que.push(root);
        //定义结果数组
        vector<int>result;
        while(!que.empty())
        {
            int size=que.size();
            for(int i=0;i<size;++i)
            {
                //定义一个指向队列头的指针
                TreeNode*node=que.front();
                //将队头出列
                que.pop();
                //判断是否到达这一层的最后一个元素
                if(i==(size-1))
                result.push_back(node->val);
                //将左右孩子入队列
                if(node->left)
                que.push(node->left);
                if(node->right)
                que.push(node->right);
            }
        }
        return result;
    }

leetcode 637 二叉树的层平均值

class Solution {
public:
    vector<double> averageOfLevels(TreeNode* root) {
        queue<TreeNode*>que;
        if(root!=nullptr)
        que.push(root);
        vector<double>result;
        while(!que.empty())
        {
            double sum=0;
            int size=que.size();
            for(int i=0;i<size;++i)
            {
                TreeNode*node=que.front();
                que.pop();
                sum+=node->val;
                if(node->left)
                que.push(node->left);
                if(node->right)
                que.push(node->right);
            }
            //将平均值传入result数组
            result.push_back(sum/size);
        }
        return result;
    }
};

leetcode 429 n叉树的层序遍历

class Solution {
public:
    vector<vector<int>> levelOrder(Node* root) {
        //n叉树，说明可以不止2个孩子，可以多个孩子,我们只要增加一个for循环即可
        queue<Node*>que;
        //判断头节点是否存在
        if(root!=nullptr)
        que.push(root);
        //结果数组,返回层数据
        vector<vector<int>>result;
        while(!que.empty())
        {
            int size=que.size();
            vector<int>vec;
            for(int i=0;i<size;++i)
            {
                Node* node=que.front();
                que.pop();
                vec.push_back(node->val);
                //因为n叉树，所以右n个孩子，所以我们不能用二叉树的模板来做了
                for(int i=0;i<node->children.size();++i)
                {
                    //将每个孩子入队列
                    if(node->children[i])
                    que.push(node->children[i]);
                }
            }
            result.push_back(vec);
        }
        return result;
    }

leetcode 515 在每个树行中找最大值
 

class Solution {
public:
    vector<int> largestValues(TreeNode* root) {
        //树行  层序遍历，比较左右孩子的大小，入数组
        queue<TreeNode*>que;
        if(root!=nullptr)
        que.push(root);
        //定义结果数组
        vector<int>result;
        while(!que.empty())
        {
            int size=que.size();
            int maxvalue=INT_MIN;//取每一层最大值
            for(int i=0;i<size;++i)
            {
                TreeNode*node=que.front();
                que.pop();
                maxvalue=node->val>maxvalue?node->val:maxvalue;
                if(node->left)
                que.push(node->left);
                if(node->right)
                que.push(node->right);
            }
            result.push_back(maxvalue);
        }
        return result;
    }
};

leetcode 116 填充每个节点的下一个右侧点指针

class Solution {
public:
    Node* connect(Node* root) {
        queue<Node*>que;
        if(root!=NULL)
        que.push(root);
        while(!que.empty())
        {
            int size=que.size();
            Node* nodepro=NULL;
            Node* node=NULL;
            //声明结果数组
            vector<int>result;
            for(int i=0;i<size;++i)
            {
                //记录头节点
                if(i==0)
                {
                    nodepro=que.front();
                    que.pop();
                    node=nodepro;
                }
                else
                {
                    node=que.front();
                    que.pop();
                    nodepro->next=node;//本层前一个结点next指向本结点
                    nodepro=nodepro->next;
                }
                if(node->left)
                que.push(node->left);
                if(node->right)
                que.push(node->right);
            }
            nodepro->next=NULL;
        }
        return root;
    }
};

leetcode117         填充每个节点的下一个右侧点指针2  代码没有变

class Solution {
public:
    Node* connect(Node* root) {
        queue<Node*>que;
        if(root!=NULL)
        que.push(root);
        while(!que.empty())
        {
            Node*nodepro=NULL;
            Node*node=NULL;
            int size=que.size();
            for(int i=0;i<size;++i)
            {
                if(i==0)
                {
                    nodepro=que.front();
                    que.pop();
                    node=nodepro;
                }
                else
                {
                    node=que.front();
                    que.pop();
                    //将nodepro指向这个
                    nodepro->next=node;
                    nodepro=node;
                }
                if(node->left)
                que.push(node->left);
                if(node->right)
                que.push(node->right);
            }
            nodepro->next=NULL;
        }
        return root;
    }
};

leetcode 104 二叉树的最大深度

class Solution {
public:
    int maxDepth(TreeNode* root) {
        queue<TreeNode*>que;
        if(root!=nullptr)
        que.push(root);
        //定义一个变量记录深度
        int deepth=0;
        while(!que.empty())
        {
            int size=que.size();
            deepth++;
            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 deepth;
    }
};

leetcode111 二叉树的最小深度

class Solution {
public:
    int minDepth(TreeNode* root) {
        queue<TreeNode*>que;
        if(root!=nullptr)
        que.push(root);
        //定义一个变量记录深度
        int deepth=0;
        while(!que.empty())
        {
            int size=que.size();
            deepth++;
            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);
                if(!node->left&&!node->right)//计算最小深度，找到没有左右孩子的，直接break
                return deepth;
            }
        }
        return deepth;
    }
};