102. Binary Tree Level Order Traversal

最新推荐文章于 2022-02-20 23:20:19 发布

shanshanhi

最新推荐文章于 2022-02-20 23:20:19 发布

阅读量301

点赞数

分类专栏： leetcode-tree 文章标签： 102 Binary Tree Level Or tree leetcode

本文链接：https://blog.csdn.net/shanshanhi/article/details/54290250

版权

leetcode-tree 专栏收录该内容

29 篇文章 1 订阅

订阅专栏

102. Binary Tree Level Order Traversal

Given a binary tree, return the level order traversal of its nodes' values. (ie, from left to right, level by level).

For example:
Given binary tree [3,9,20,null,null,15,7],

return its level order traversal as:

[
  [3],
  [9,20],
  [15,7]
]

题意：逐层打印二叉树上的节点

代码一、采用二叉树的层次遍历的思想进行

vector<vector<int>> levelOrder(TreeNode* root) {
        //采用的是二叉树的层次遍历思想，其中每一层的数据用一个临时temp的vector<int>来保存
        if(NULL == root)
            return vector<vector<int>>();
        
        queue<TreeNode*> que;
        que.push(root);
        int countLenNodes = 1; //记录的是每一层上的节点数
        vector<vector<int>> result;
        vector<int> temp;
        while(!que.empty())
        {
            TreeNode* tempNode = que.front();
            temp.push_back(tempNode->val);
            que.pop();
            countLenNodes--;
            
            if(tempNode->left != NULL)
                que.push(tempNode->left);
            if(tempNode->right != NULL)
                que.push(tempNode->right);
            if(countLenNodes == 0)
            {
                result.push_back(temp);
                temp.resize(0); //或者temp.clear()均可以
                countLenNodes = que.size();
            }
        }
        return result;
    }

方法二、前序递归遍历构建vector

vector<vector<int>> result;
    
    void buildVector(TreeNode* root, int depth)
    {
        if(NULL == root)
            return;
        if(result.size() == depth) //？？？当开创新的层次的时候，采用该语句进行申请空间
            result.push_back(vector<int>());
        
        result[depth].push_back(root->val);
        buildVector(root->left,depth + 1);
        buildVector(root->right,depth + 1);
    }
    
    vector<vector<int>> levelOrder(TreeNode* root) {
        buildVector(root,0);
        return result;
    }

方法三、传统的两个队列的解决方案

class Solution {  
public:  
    vector<vector<int>> levelOrder(TreeNode* root)   
    {  
          
        
    vector<vector<int>> result;  
    queue<TreeNode*> q;  
  
    if (root == NULL)  
    {  
        return result;  
    }  
    q.push(root);  
    vector<int> le_temp;  
  
    while(!q.empty())  
    {  
  
        le_temp.clear();  
        queue<TreeNode*> level;  
              
        int size = q.size();      
        for(int i = 0; i < size; ++i)  
        {  
            TreeNode* temp = q.front();  
            q.pop();  
            if(temp->left)  
            {  
                level.push(temp->left);  
            }  
            if(temp->right)  
            {  
                level.push(temp->right);  
                  
            }  
            le_temp.push_back(temp->val);  
        }  
  
        while(!level.empty())  
        {  
  
            q.push(level.front());     
            level.pop();  
        }  
        result.push_back(le_temp);  
    }  
  
    return result;  
          
    }  
};