32-03 按之字形顺序打印二叉树

题目

请实现一个函数按照之字形打印二叉树，即第一行按照从左到右的顺序打印，第二层按照从右至左的顺序打印，第三行按照从左到右的顺序打印，其他行以此类推。

如图：

打印效果：

LeetCode

C++ 题解

在打印某一行结点时，把下一层结点的子结点保存到相应的栈里：
如果当前打印的是奇数层（第一层、第三层等），则先保存左子结点再保存右子结点到第一个栈里；
如果当前打印的是偶数层（第二层、第四层等），则先保存右子结点再保存左子结点到第二个栈里。
总之而言，当打印一个栈时，它的子结点保存到另一个栈里。当一层所有结点都打印完之后，交换两个栈并继续打印下一层。

/**
 * 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) {
        
        if(root ==NULL)
            return {};
        
        stack<TreeNode*> s;
        stack<TreeNode*> q;
        //使用哪个栈
        int flag = 0;
        vector<vector<int>> res;
        s.push(root);
        
        while(!s.empty() || !q.empty())
        {
            
           if(flag == 0)
           {
               vector<int> v_t;
               flag = 1;
               while(!s.empty())
               {
                   TreeNode* tmp = s.top();
                   s.pop();
                   v_t.push_back(tmp->val);
                   if(tmp->left) 
                       q.push(tmp->left);
                   if(tmp->right) 
                       q.push(tmp->right);
                    
               }
               if(v_t.size()>0) 
                   res.push_back(v_t);
               
           }
           else
           {
               vector<int> v_t;
               flag = 0;
               while(!q.empty())
               {
                   TreeNode* tmp = q.top();
                   q.pop();
                   v_t.push_back(tmp->val);
                   if(tmp->right) 
                       s.push(tmp->right);
                   if(tmp->left) 
                       s.push(tmp->left);
                    
               }
               if(v_t.size()>0) 
                   res.push_back(v_t);
           }
            
        }
        return res;           
    }
};

python 题解

方法一

思路与C++题解一致：

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution(object):
    def zigzagLevelOrder(self, root):
        """
        :type root: TreeNode
        :rtype: List[List[int]]
        """

        if not root:
            return []
        res=[]
        nodes=[root]
        right=True
        
        while nodes:
            curStack,nextStack=[],[]
            if right:
                for node in nodes:
                    curStack.append(node.val)
                    if node.left:
                        nextStack.append(node.left)
                    if node.right:
                        nextStack.append(node.right)
            else:
                for node in nodes:
                    curStack.append(node.val)
                    if node.right:
                        nextStack.append(node.right)
                    if node.left:
                        nextStack.append(node.left)
            res.append(curStack)
            nextStack.reverse()
            right=not right
            nodes=nextStack
        return res

方法二

较为简洁的解法

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution(object):
    def zigzagLevelOrder(self, root):
        """
        :type root: TreeNode
        :rtype: List[List[int]]
        """
        
        if root == None:
            return 
        
        LeftToRight = True        
        res = []
        nodes = [root]
        
        while nodes:
            currentstack,nextstack = [],[]
            
            for node in nodes:
                currentstack.append(node.val)
                if node.left:
                    nextstack.append(node.left)
                if node.right:
                    nextstack.append(node.right)
            
            if not LeftToRight:
                currentstack.reverse()
            
            res.append(currentstack)
            
            nodes = nextstack
            LeftToRight = not LeftToRight
        
        return res