平层打印二叉树

1. 问题描述：

给定一个二叉树，按照从左到右的顺序逐层打印各节点数据。

2. 分析

问题的关键，在于用一个容器来存储单层的所有节点地址——有了某一层所有节点地址，则可获取下一层所有节点的地址。

3. 解决方案

用一个队列来存储节点地址。首先压入根节点，然后对队列进行如下操作：每pop一次，打印弹出节点的数据，并弹出节点的非空子节点压入队列，直到队列为空。

4. 代码

/*********************************/
/* BTreePrintTest                */
/*********************************/
#include <cstdlib>
#include <cstdio>
#include <queue>
#include <conio.h>

using namespace std;

// 节点类型.
typedef struct _bTree_Node
{
	int data;
	_bTree_Node * pLeft;
	_bTree_Node * pRight;
}BTreeNode;

// 测试方法.
static void BTreePrintTest();
// 生成一个节点.
static BTreeNode * GenerateBTreeNode(int data);
// 先序打印.
static void PrintBTree_Pre(BTreeNode * pBTree);
// 中序打印.
static void PrintBTree_In(BTreeNode * pBTree);
// 后序打印.
static void PrintBTree_Post(BTreeNode * pBTree);
// 平层打印.
static void PrintBTree_Level(BTreeNode * pBTree);


int main()
{
	BTreePrintTest();
	
	printf("Press any key to continue...""\n");
	_getch();
	
	return 0;
}


void BTreePrintTest()
{
	int i;
	int dataArray[12] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11};
	BTreeNode * NodePtrArray[12] = {0};

	// 上帝说：要有米才能炊.
	for(i=0; i<12; ++i)
	{
		NodePtrArray[i] = GenerateBTreeNode(dataArray[i]);

		if(NULL == NodePtrArray[i])
		{
			// printf("");
			return;
		}
	}
	NodePtrArray[0]->pLeft	= NodePtrArray[1];
	NodePtrArray[0]->pRight	= NodePtrArray[2];
	
	NodePtrArray[1]->pLeft	= NodePtrArray[3];
	NodePtrArray[1]->pRight	= NodePtrArray[4];

	NodePtrArray[2]->pLeft	= NodePtrArray[5];
	NodePtrArray[2]->pRight	= NodePtrArray[6];

	NodePtrArray[3]->pLeft	= NodePtrArray[7];
	NodePtrArray[3]->pRight	= NodePtrArray[8];

	NodePtrArray[4]->pLeft	= NodePtrArray[9];
	NodePtrArray[4]->pRight	= NodePtrArray[10];

	NodePtrArray[5]->pLeft	= NodePtrArray[11];

	// 先序打印.
	printf("Pre: ");
	PrintBTree_Pre(NodePtrArray[0]);
	printf("\n");

	// 中序打印.
	printf("In: ");
	PrintBTree_In(NodePtrArray[0]);
	printf("\n");

	// 后序打印.
	printf("Post: ");
	PrintBTree_Post(NodePtrArray[0]);
	printf("\n");


	// 平层打印.
	PrintBTree_Level(NodePtrArray[0]);
}


BTreeNode * GenerateBTreeNode(int data)
{
	BTreeNode * pNode;

	pNode = new BTreeNode;
	if(NULL != pNode)
	{
		pNode->data = data;
		pNode->pLeft = NULL;
		pNode->pRight = NULL;
	}

	return pNode;
}

static void PrintBTree_Pre(BTreeNode * pBTree)
{
	if(NULL != pBTree)
	{
		printf("%d ", pBTree->data);
		PrintBTree_Pre(pBTree->pLeft);
		PrintBTree_Pre(pBTree->pRight);
	}
}

static void PrintBTree_In(BTreeNode * pBTree)
{
	if(NULL != pBTree)
	{
		PrintBTree_In(pBTree->pLeft);
		printf("%d ", pBTree->data);
		PrintBTree_In(pBTree->pRight);
	}
}

static void PrintBTree_Post(BTreeNode * pBTree)
{
	if(NULL != pBTree)
	{
		PrintBTree_Post(pBTree->pLeft);
		PrintBTree_Post(pBTree->pRight);
		printf("%d ", pBTree->data);
	}
}

void PrintBTree_Level(BTreeNode * pBTree)
{
	queue<BTreeNode *> nodePtrQueue;
	BTreeNode * pTempNode;

	if(NULL == pBTree)
	{
		return;
	}

	printf("Level: ");
	nodePtrQueue.push(pBTree);
	while(!nodePtrQueue.empty())
	{
		pTempNode = nodePtrQueue.front();

		if(NULL != pTempNode->pLeft)
		{
			nodePtrQueue.push(pTempNode->pLeft);
		}
		if(NULL != pTempNode->pRight)
		{
			nodePtrQueue.push(pTempNode->pRight);
		}

		printf("%d ", pTempNode->data);
		
		nodePtrQueue.pop();
	}
	printf("\n");
}

5. 运行结果