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

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]
]

题意分析： 

给定一个二分搜索树，返回“之字形”式广度优先遍历后节点的值。“之字形”式广度优先遍历为第一层从左往右，第二层从右往左，第三层又从左往右...... 依次从根节点到叶子节点交替遍历下去。

解答如下：

方法一（堆栈法）

        先建立两个栈，根据栈后进先出的特点，分别存放相邻两行的节点值。另外节点值进栈的顺序是不相同，一个栈是先进左子结点值再进右子节点值，另一个栈是先进右子节点值再进左子结点，因此子结点值出栈的顺序就是所求的之字形了。

class Solution{
public:
    vector<vector<int>> zigzagLevelOrder( TreeNode* root ){
        vector<vector<int>> res;
        if (!root) return res;
        vector<int> level;
        stack<TreeNode*> s1;
        stack<TreeNode*> s2;
        s1.push( root );
        while( !s1.empty() || !s2.empty() ){
            while( !s1.empty() ){                  //从右往左存储子节点值
                TreeNode* node = s1.top(); 
                s1.pop();
                level.push_back( node-> val );
                if( node->left ) s2.push( node->left );
                if( node->right ) s2.push( node->right );
            }
            if ( !level.empty() ) res.push_back( level );
            level.clear();

            while( !s2.empty() ){                  //从左往右存储子节点值
                TreeNode* node = s2.top();
                s2.pop();
                level.push_back( node-> val );
                if( node->right ) s1.push( node->right );
                if( node->left ) s1.push( node->left );
            }
            if ( !level.empty() ) res.push_back( level );   //避免将清空的level再存储一遍
            level.clear();
        }
        return res;
    }
};

提交后的结果如下：

 

方法二（队列法）

新建一个用于存放节点的队列，由于队列先进先出的原则，所以需要对不同层的节点值进行不同顺序存放。为了达到题目要求，故当层数为奇数时，从左往右存节点值，当层数为偶数时，从右往左存节点值，且层数从1开始计算。

class Solution{
public:
    vector<vector<int>> zigzagLevelOrder(TreeNode* root){
        vector<vector<int>> res;
        if ( !root )
            return res;
        int k = 1;                                            //记录层数且层数从1开始
        queue< TreeNode* > q;
        q.push( root );
        while ( !q.empty() ){
            vector<int> level;                                //建立存放每一层节点值的向量
            for (int i = q.size(); i > 0 ; i--) {             //存储某一层节点值以及下一层的节点
                TreeNode* node = q.front();
                q.pop();
                if( k % 2 != 0 )                               //判断奇偶层
                    level.push_back( node->val );              //当层数为奇数时，从左往右存节点值
                else                                           //当层数为偶数时，从右往左存节点值
                    level.insert( level.begin(), node->val );
                if ( node->left )
                    q.push( node->left );
                if ( node->right )
                    q.push( node->right );
            }
            res.push_back( level );
            k ++;                                                //更新层数
        }
        return res;
    }
};

提交后的结果如下：

日积月累，与君共进，增增小结，未完待续。