LeetCode OJ 之 Binary Tree Zigzag Level Order Traversal （二叉树的曲线层次遍历）

最新推荐文章于 2021-06-29 15:27:32 发布

思翊

最新推荐文章于 2021-06-29 15:27:32 发布

阅读量625

点赞数

分类专栏： Leetcode OJ

本文链接：https://blog.csdn.net/u012243115/article/details/42150189

版权

Leetcode OJ 专栏收录该内容

199 篇文章 2 订阅

订阅专栏

题目：

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,#,#,15,7},

return its zigzag level order traversal as:

[
  [3],
  [20,9],
  [15,7]
]

思路：

广度优先遍历，用一个bool 记录是从左到右还是从右到左，每一层结束就翻转一下。

迭代版代码：

/**
 * Definition for binary tree
 * 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> > result;//保存结果
        vector<int> path;//当前层的元素
        if(root == NULL)
            return result;
        queue<TreeNode *> que;
        que.push(root);
        int curlen = 1;//当前层的元素个数，初始值为1，只有一个root
        int nextlen = 0;//下一层的元素个数
        bool isRightToLeft = false;//第一次不是从右到左，初始化为false
        while(!que.empty() || curlen != 0)
        {
            TreeNode *p = que.front();
            que.pop();
            path.push_back(p->val);
            curlen--;
            if(p->left)
            {
                que.push(p->left);
                nextlen++;
            }
            if(p->right)
            {
                que.push(p->right);
                nextlen++;
            }
            //如果当前层的元素遍历完，则判断是否是从右到左的顺序，如果是需要先翻转path，再push进result中
            if(curlen == 0)
            {
                if(isRightToLeft)
                    reverse(path.begin(),path.end());
                result.push_back(path);
                path.clear();
                curlen = nextlen;
                nextlen = 0;
                isRightToLeft = !isRightToLeft;//下次设置成反方向
            }
        }
        return result;
    }
};

递归版代码：

/**
 * Definition for binary tree
 * 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> > result;
        traverse(root,result,1,true);
        return result;
    }
    void traverse(TreeNode *root , vector<vector<int> > &result , int level , bool isLeftToRight)
    {
        if(root == NULL)
            return ;
        if(level > result.size())
            result.push_back(vector<int>());
        if(isLeftToRight)
            result[level-1].push_back(root->val);//在后插入
        else
            result[level-1].insert(result[level-1].begin(),root->val);//在前面插入
        traverse(root->left,result,level+1,!isLeftToRight);//下一层，isLeftToRight要取反
        traverse(root->right,result,level+1,!isLeftToRight);
    }
};