*Leetcode 103. Binary Tree Zigzag Level Order Traversal

最新推荐文章于 2025-09-11 19:19:55 发布

原创最新推荐文章于 2025-09-11 19:19:55 发布 · 153 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#leetcode

leetcode 笔记专栏收录该内容

127 篇文章

订阅专栏

本文介绍了一种特殊的二叉树遍历方法——锯齿形层级遍历，并提供了两种实现方式：一种利用递归进行节点值的收集，随后根据层级奇偶性反转列表；另一种采用双向队列进行迭代遍历，根据遍历方向的不同调整节点的加入顺序。

Given a binary tree, return the zigzag level order traversal of its nodes’ values. (ie, from left to right, then right to left for the next level and alternate between).

For example:
Given binary tree [3,9,20,null,null,15,7],
3
/ \
9 20
/ \
15 7
return its zigzag level order traversal as:
[
[3],
[20,9],
[15,7]
]

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    vector<vector<int>> zigzagLevelOrder(TreeNode* root) {
        vector<vector<int> > ret;
        reRead(root, ret, 0);
        for (size_t i = 1; i < ret.size(); i += 2) {
            size_t n = ret[i].size();
            for (size_t j = 0; j != n / 2; ++j) {
                swap(ret[i][j], ret[i][n - 1 - j]);
            }
        }
        return ret;
    }


private:
    void reRead(TreeNode* r, vector<vector<int> >& ret, int id) {
        if (r == nullptr) return;

        if (id < ret.size())
            ret[id].emplace_back(r->val);
        else 
            ret.emplace_back(vector<int>{r->val});

        reRead(r->left, ret, id + 1);
        reRead(r->right, ret, id + 1);
    }
};

参考后
deque 数据结构之美

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    vector<vector<int>> zigzagLevelOrder(TreeNode* root) {
        vector<vector<int> > ret;
        if (root == nullptr) return ret;
        deque<TreeNode*> d;
        d.push_back(root);
        bool forward = 1;

        while(!d.empty()) {
            size_t n = d.size();
            vector<int>row;
            for (size_t i = 0; i != n; ++i) {
                if (forward) {
                    TreeNode* r = d.front();
                    d.pop_front();
                    row.emplace_back(r->val);

                    if (r->left != nullptr) d.push_back(r->left);
                    if (r->right != nullptr) d.push_back(r->right);
                } else {
                    TreeNode* r = d.back();
                    d.pop_back();
                    row.emplace_back(r->val);

                    if (r->right != nullptr) d.push_front(r->right);
                    if (r->left != nullptr) d.push_front(r->left);
                }
            }
            forward ^= 1;
            ret.emplace_back(row);
        }

        return ret;
    }
};