剑指Offer刷题笔记——按之字顺序打印二叉树

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

我也是服了，好好的二叉树非得之字打印。

说归说，闹归闹，别拿刷题开玩笑。它是以层为单位，和普通的广度搜索（层次搜索）不同，它相邻的层之间打印的次序相反。一个比较好想的思路就是，在广度优先搜索的基础上，改变队列的建立规则

def Print(self, pRoot):        
    if pRoot == None:            
        return []        
    else:            
        result = []
        # 存储当前层的结点            
        node_list = [pRoot]    
        # 记录奇偶行的标志变量        
        row = 1            
        while node_list != []:
            # 存储下一层的结点                
            child_list = [] 
            # 存储每一层的数值               
            row_list = []    
            # 根据当前层的结点，把本层数值放入row_list，下层的子节点放入child_list          
            for i in node_list:                    
                row_list.append(i.val)                    
                if i.left != None:                        
                    child_list.append(i.left)                    
                if i.right != None:                        
                    child_list.append(i.right)  
            # 更新当前层的结点              
            node_list = child_list
            # 偶数行位置颠倒                
            if row %2 == 0:                    
                row_list.reverse()                
            result.append(row_list)                
            row += 1            
        return result

这里row_list.reverse()据说海量数据时候，会增加复杂度。所以用空间换时间，用两个栈来解决。

# -*- coding:utf-8 -*-
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
class Solution:
    def Print(self, pRoot):
        # write code here
        if pRoot == None:
            return []
        stack1 = [pRoot]
        stack2 = []
        result = []
        while (stack1 or stack2):
            ret1 = []   # 用来暂时存储各层节点的值
            ret2 = []   # 用来暂时存储各层节点的值
            while stack1:
                node = stack1.pop()
                # 先左后右入栈2
                if node.left:
                    stack2.append(node.left)
                if node.right:
                    stack2.append(node.right)
                ret1.append(node.val)
            if len(ret1) != 0:
                result.append(ret1)
            while stack2:
                node = stack2.pop()
                # 先右后左入栈1
                if node.right:
                    stack1.append(node.right)
                if node.left:
                    stack1.append(node.left)
                ret2.append(node.val)
            if len(ret2) != 0:
                result.append(ret2)
        return result