代码随想录-二叉树

1、迭代遍历

2、

07. 二叉树的层序遍历 II

/**
 * 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:
    vector<vector<int>> levelOrderBottom(TreeNode* root) {
        queue<TreeNode*>astack;
        vector<vector<int>> ret;
        if(root == NULL) return ret;
        astack.push(root);
        while(astack.size()>0){
            vector<int>b;
            int len = astack.size();
            for(int i = 0; i < len; i++) {
                TreeNode *tmp = astack.front();
                astack.pop();
                b.push_back(tmp->val);
                if(tmp->left != NULL)
                    astack.push(tmp->left);
                if(tmp->right != NULL) 
                    astack.push(tmp->right);
            }
            ret.push_back(b);
        }
        reverse(ret.begin(), ret.end());
        return ret;
    }
};

199. 二叉树的右视图

/**
 * 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:
    vector<int> rightSideView(TreeNode* root) {
        queue<TreeNode *> qtree;
        vector<int>ret;
        if(root == NULL) return ret;
        qtree.push(root);
        while(qtree.size() > 0) {
            int len = qtree.size();
            for(int i = 0; i < len-1; i++) {
                TreeNode *tmp = qtree.front();
                qtree.pop();
                if(tmp->left != NULL) {
                    qtree.push(tmp->left);
                }
                if(tmp->right != NULL) {
                    qtree.push(tmp->right);
                }
            }
                TreeNode *tmp = qtree.front();
                ret.push_back(tmp->val);
                qtree.pop();
                if(tmp->left != NULL) {
                    qtree.push(tmp->left);
                }
                if(tmp->right != NULL) {
                    qtree.push(tmp->right);
                }
        }
        return ret;
    }
};

637. 二叉树的层平均值

/**
 * 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:
    vector<double> averageOfLevels(TreeNode* root) {
        queue<TreeNode *> qtree;
        vector<double>ret;
        if(root == NULL) return ret;
        qtree.push(root);
        while(qtree.size() > 0) {
            int len = qtree.size();
            double sum = 0;
            for(int i = 0; i < len; i++) {
                TreeNode *tmp = qtree.front();
                sum += tmp->val;
                qtree.pop();
                if(tmp->left != NULL) {
                    qtree.push(tmp->left);
                }
                if(tmp->right != NULL) {
                    qtree.push(tmp->right);
                }
            }
            ret.push_back(sum/len);
        }
        return ret;
    }
};

429. N 叉树的层序遍历


 

/*
// 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:
    vector<vector<int>> levelOrder(Node* root) {
        queue<Node *>tqueue;
        vector<vector<int>> ret;
        if(root == NULL) return ret;
        tqueue.push(root);
        while(tqueue.size() > 0) {
            int size = tqueue.size();
            vector<int>a;
            for(int i = 0; i < size; i++) {
                 Node *tmp = tqueue.front();
                tqueue.pop();
                a.push_back(tmp->val);
                for(int j = 0; j < tmp->children.size(); j++) {
                    if(tmp->children[j] != NULL) {
                        tqueue.push(tmp->children[j]);
                    }
                }
                
            }
            ret.push_back(a);
        }
        return ret;
    }
};