代码随想录算法训练营第15天

二叉树的层序遍历

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

递归法的理解

# 递归法
class Solution {
public:
    void order(TreeNode* cur, vector<vector<int>>& result, int depth)
    {
        if (cur == nullptr) return;
        if (result.size() == depth) result.push_back(vector<int>());
        result[depth].push_back(cur->val);
        order(cur->left, result, depth + 1);
        order(cur->right, result, depth + 1);
    }
    vector<vector<int>> levelOrder(TreeNode* root) {
        vector<vector<int>> result;
        int depth = 0;
        order(root, result, depth);
        return result;
    }
};

vector<vector<int>> table(size1, vector<int>(size2, 0));

二维数组结构解释

• size1：初始化设置有几个vector数组
• size2：设置每个vector中有几个元素
• 0：设置vector中初值

获取行和列：

vector<vector<int>> v(2, vector<int>(3, 1));
int row=v.size();

vector<vector<int>> v(2, vector<int>(3, 1));
int col=v[0].size();
//行row为2，列col为3

行的解释：行即为数组中有几个vector

列的解释：列指二维数组中一个vector有几个元素

v[0]就是二维数组中第一个行，第一个vector

LeetCode 226.翻转二叉树

class Solution {
public:
    TreeNode* invertTree(TreeNode* root) {
        queue<TreeNode*> que;
        if(root!=NULL)que.push(root);
        while(que.empty()!=true){
            int size=que.size();
            for(int i=0;i<size;i++){
                TreeNode* node=que.front();
                que.pop();
                swap(node->left,node->right);
                if(node->left)que.push(node->left);
                if(node->right)que.push(node->right);
            }
        }
        return root;
    }
};

层序遍历实现

LeetCode 101. 对称二叉树

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

        bool outside=compare(left->left,right->right);
        bool inside=compare(left->right,right->left);
        return outside && inside;
    }
    bool isSymmetric(TreeNode* root) {
        if(root==NULL)return true;
        return compare(root->left,root->right);
    }
};

这里要注意把情况分析清楚，然后只有当left->val==right->val时，才进入下一步左右子树的判断。