LintCode 71: Binary Tree Zigzag Level Order Traversal

最新推荐文章于 2025-12-20 17:21:30 发布

原创最新推荐文章于 2025-12-20 17:21:30 发布 · 135 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#算法 #leetcode

本文介绍了一种二叉树的特殊遍历方式——锯齿形层序遍历，通过三种不同的实现方法，包括使用队列、逆序插入和递归方式，详细解析了如何获取二叉树节点值的锯齿形层次顺序。

Binary Tree Zigzag Level Order Traversal

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).

Example
Example 1:

Input:{1,2,3}
Output:[[1],[3,2]]
Explanation:
1
/
2 3
it will be serialized {1,2,3}
Example 2:

Input:{3,9,20,#,#,15,7}
Output:[[3],[20,9],[15,7]]
Explanation:
3
/
9 20
/
15 7
it will be serialized {3,9,20,#,#,15,7}

解法1：

/**
 * Definition of TreeNode:
 * class TreeNode {
 * public:
 *     int val;
 *     TreeNode *left, *right;
 *     TreeNode(int val) {
 *         this->val = val;
 *         this->left = this->right = NULL;
 *     }
 * }
 */

class Solution {
public:
    /**
     * @param root: A Tree
     * @return: A list of lists of integer include the zigzag level order traversal of its nodes' values.
     */
    vector<vector<int>> zigzagLevelOrder(TreeNode * root) {
        if (!root) return {};
        queue<TreeNode *> q;
        q.push(root);
        bool left2Right = true;
        vector<int> levelNodesValue;
        vector<vector<int>> result;
        
        while(!q.empty()) {
            int qSize = q.size();
            for (int i = 0; i < qSize; ++i) {
                TreeNode * node = q.front();
                q.pop();
                levelNodesValue.push_back(node->val);
                if (node->left) q.push(node->left);
                if (node->right) q.push(node->right);
            }
            
            if (left2Right) {
                left2Right = false;
            } else {
                reverse(levelNodesValue.begin(), levelNodesValue.end());
                left2Right = true;
            }            
            result.push_back(levelNodesValue);
            levelNodesValue.clear();
        }
        return result;
    }
};

解法2：网上看到的，觉得不错。

class Solution {
public:
    vector<vector<int>> zigzagLevelOrder(TreeNode* root) {
        if (!root) return {};
        vector<vector<int>> res;
        queue<TreeNode*> q{{root}};
        bool leftToRight = true;
        while (!q.empty()) {
            int size = q.size();
            vector<int> oneLevel(size);
            for (int i = 0; i < size; ++i) {
                TreeNode *t = q.front(); q.pop();
                int idx = leftToRight ? i : (size - 1 - i);
                oneLevel[idx] = t->val;
                if (t->left) q.push(t->left);
                if (t->right) q.push(t->right);
            }
            leftToRight = !leftToRight;
            res.push_back(oneLevel);
        }
        return res;
    }
};

解法3：也是网上看到的，觉得不错。
注意vector可以从前面插入oneLevel.insert(oneLevel.begin(), node->val);

class Solution {
public:
    vector<vector<int>> zigzagLevelOrder(TreeNode* root) {
        vector<vector<int>> res;
        helper(root, 0, res);
        return res;
    }
    void helper(TreeNode* node, int level, vector<vector<int>>& res) {
        if (!node) return;
        if (res.size() <= level) {
            res.push_back({});
        }
        vector<int> &oneLevel = res[level];
        if (level % 2 == 0) oneLevel.push_back(node->val);
        else oneLevel.insert(oneLevel.begin(), node->val);
        helper(node->left, level + 1, res);
        helper(node->right, level + 1, res);
    }
};