剑指offer打印二叉树

32.重上到下打印二叉树
题目：从上往下打印出二叉树的每个节点，同层节点从左至右打印。
思路：没打印一个节点时，如果该节点有子节点，就把该子节点放到队列的末尾，接下来到队列的头部去除最早入队的节点

struct TreeNode {
	int val;
	struct TreeNode *left;
	struct TreeNode *right;
	TreeNode(int x) :
			val(x), left(NULL), right(NULL) {
	}
};

void PrintFormTopToBottom(TreeNode* root)
{
 
	 if(!root)
            return;
        std::deque<TreeNode*>dequeTreeNode;
        dequeTreeNode.push_back(root);
        
        while(dequeTreeNode.size())
        {
            TreeNode *pNode=dequeTreeNode.front();
            dequeTreeNode.pop_front();
            printf("%d",pNode->val);
            
            if(pNode->left)
                dequeTreeNode.push_back(pNode->left);
            if(pNode->right)
                dequeTreeNode.push_back(pNode->right);
        }
}

 

分行从上到下打印二叉树
题目：从上到下按层打印二叉树，同一层结点从左至右输出。每一层输出一行。
思路：与前面那一个类试。不过为了把二叉树的每一行单独打印到一行，我们需要两个变量
    一个变量表示当前层中还没有打印的节点树
    另一个变量是表示下一层的节点数

struct TreeNode {
	int val;
	struct TreeNode *left;
	struct TreeNode *right;
	TreeNode(int x) :
			val(x), left(NULL), right(NULL) {
	}

void Print(TreeNode *pRoot)
{
	if(pRoot==nullptr)
	return;
	std::queue<BinaryTreeNode*>nodes;
	//把头节点入队 
	nodes.push(pRoot);
	//下一层的节点数 
	int nextLevel=0;
	//当前层还没有打印的节点数 
	int toBePrint=1;
	while(!nodes.empty())
	{
		//定义一个节点的指针来获取队头元素 
		TreeNode *pNode=nodes.front();
		printf("%d",pNode->val);
		if(pNode->left!=nullptr)
		{
			nodes.push(pNode->left);
			++nextLevel;
		}
		if(pNode->right!=nullptr)
		{
			nodes.push(pNode->right);
			++nextLevel;
		} 
		nodes.pop();
		--toBePrint;
		if(toBePrint==0)
		{
			printf("\n");
			toBePrint=nextLevel;
			nextLevel=0;
		}
	} 

 

之字形打印二叉树
题目：请实现一个函数按照之字形打印二叉树，即第一行按照从左到右的顺序打印，第二层按照从右至左的顺序打印，第三行按照从左到右的顺序打印，其他行以此类推。
思路：按之字形打印需要两个栈1.当打印奇数层时，先保存左子节点再保存右子节点到第一个栈
            2.当打印偶数层时，先保存右子节点在保存左子节点到第二个栈

 

#include<stdio.h>

struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
    TreeNode(int x) :
            val(x), left(NULL), right(NULL) {
    }
};

void Print(TreeNode*pRoot)
{
	if(pRoot==nullptr)
		return;
	//定义level[0]和level[1]两个栈
	std::stack<TreeNode*>levels[2];
	int current=0;
	int next=1;
	//把根节点入栈 
	levels[current].push(pRoot);
	
	while(!levels[0].empty()||!levels[1].empty())
	{
		TreeNode *pNode=levels[current].top();
		levels[current].pop();
		
		printf("%d",pNode->val);
		//在打印一个栈里的节点时，他的子节点保存另一个栈中。
		//当一层所有的节点都打印完毕时，交换这两个栈并继续打印下一层 
		if(current==0)
		{
			if(pNode->left!=nullptr)
				levels[next].push(pNode->left);
			if(pNode->right!=nullptr)
				levels[next].push(pNode->right);					
		}
		else
		{
			if(pNode->right!=nullptr)
				levels[next].push(pNode->right);
			if(pNode->left!=nullptr)
				levels[next].push(pNode->left);
		}
		if(levels[current].empty())
		{
			printf("\n");
			current=1-current;
			next=1-next;
		} 
	} 
}