代码随想录算法训练营第15天 | 102.二叉树的层序遍历、226. 翻转二叉树、101. 对称二叉树

day15

102.二叉树的层序遍历

分析：光层序不难，难点在于分层输出。

思路：输出是vector<vector<int>>，队列里只留一层的结点，

思路1：两个队列，上层弹出后下层全部到上层；（可以实现）

思路2：queue<vector<TreeNode*>>，

思路3（自己没想到）：每次开始一层时，记录当前que的size，这样就能在这一层pop完时停止小循环，同时开启下一轮。

这里面的区别是，善用寄存器和flag变量。

//队列迭代
class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        queue<TreeNode*> que;
        if (root != NULL) que.push(root);
        vector<vector<int>> result;
        while (!que.empty()) {
            int size = que.size();
            vector<int> vec;
            // 这里一定要使用固定大小size，不要使用que.size()，因为que.size是不断变化的
            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;
    }
};

这里也要记录一下递归法，很巧妙，二维向量里每个该填的格子都由一个递归来完成，深度决定了[x][]，递归调用的次序决定了[][y]。

// 递归法
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;
    }
};

107. 二叉树的层序遍历 II

返回自底向上的遍历，只把结果reverse一下即可；

199. 二叉树的右视图

只取每层最右第一个；

429. N 叉树的层序遍历

代码里把访问左右孩子变成了一个for循环访问所有孩子。

N叉树的结点定义倒是可以学习一下：

class Node {
public:
    int val;
    vector<Node*> children;
	// 构造函数
    Node() {}
	// 多态
    Node(int _val) {
        val = _val;
    }
	// 多态
    Node(int _val, vector<Node*> _children) {
        val = _val;
        children = _children;
    }
};

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

一个max记录就行了，主要是每次的size做了很好的循环分层，无压力~

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

一样，扒去皮，还是一样的操作，不过是在每个for循环里，记录一下上一个节点；

104. 二叉树的最大深度

单想本题会立马想到递归，但用队列也挺好玩，毕竟都要遍历全部结点。

111. 二叉树的最小深度

好像也能用递归做，但是队列就很容易理解了

递归：对于每一个非叶子节点，我们只需要分别计算其左右子树的最小叶子节点深度。

226. 翻转二叉树

不确定反转的效果就多演算几个例子。swap直接可以翻转两个子树。

class Solution {
public:
    TreeNode* invertTree(TreeNode* root) {
        if (root == NULL) return root;
        swap(root->left, root->right);  // 中
        invertTree(root->left);         // 左
        invertTree(root->right);        // 右
        return root;
    }
};

101. 对称二叉树

也可以用迭代法，只要左右对称的两个同时处理就行了。

善用函数，将大任务分解。