程序员面试金典： 9.4树与图 4.4 在二叉树上创建包含某一深度上所有节点的链表

#include <iostream>
#include <stdio.h>
#include <string>
#include <queue>
#include <vector>

using namespace std;

/*
问题：给定一颗二叉树，设计一个算法，创建含有某一深度上所有节点的链表（比如，若一棵树的深度为D,
则会创建出D个链表）。
分析：题目的意思应该是深度为1的所有节点构成一个链表，深度为2的所有节点构成一个链表,....,也就是把
      相同深度的节点放在同一个链表中。
	  那么肯定要遍历，我们知道层次遍历最好的方式应该是用广度优先。可以事先创建D个链表，
	  每当遍历到一个节点，获取该节点深度，将该节点放入到对应深度的链表中，结点插入链表的方式可以采用
	  尾插法。
	  当所有结点遍历结束，此时D个链表也已经建立好。
	  而树的深度D，可以通过一个递归实现。

输入:
6(树中结点个数n)
1 2 3 4 5 6（树中结点的值，接下来有n行，每i行第一个字符：'d'表示第i个结点有两个孩子，随后给出两个孩子节点编号，
'l'表示第i个结点只有左孩子，然后给出左孩子结点编号；'r'表示第i个结点只有右孩子，给出右孩子节点编号,'z'表示第i个结点没有孩子结点）
d 2 3
d 4 5
r 6
z
z
z
输出:
depth 1: 1 ,depth 2: 2 3, depth 3: 4 5 6
*/
const int MAXSIZE = 10000;

typedef struct TreeNode
{
	int _value;
	TreeNode* _pLeft;
	TreeNode* _pRight;
	bool _isVisited;
	int _height;
	//TreeNode* _pParent;
}TreeNode;
int g_index;
TreeNode g_treeNodeArray[MAXSIZE];

typedef struct Node
{
	Node* _pNext;
	int _value;
}Node;

TreeNode* createTreeNode()
{
	++g_index;
	g_treeNodeArray[g_index]._pLeft = g_treeNodeArray[g_index]._pRight = NULL; 
	g_treeNodeArray[g_index]._isVisited = false;
	return &g_treeNodeArray[g_index];
}

vector< Node* > visitTreeBFS(TreeNode* head)
{
	vector<Node*> vecNode;
	if(NULL == head)
	{
		return vecNode;
	}
	queue<TreeNode*> queueTree;
	head->_height = 0;//设置根结点的高度为1
	queueTree.push(head);
	vector<Node*> tailNodeVector; //用于存放对应链表的尾结点
	while(!queueTree.empty())
	{
		TreeNode* treeNode = queueTree.front();
		queueTree.pop();
		int height = treeNode->_height;

		//将当前节点加入到与其深度相统一的链表中，说明深度为height对应的链表还没有建立
		if(vecNode.empty() || height == vecNode.size() )
		{
			//建立链表，尾插法，创建尾结点，创建一个新节点，令尾结点为新结点；后续再插结点时，令尾结点指向新结点，再令尾结点为新结点
			Node* pNode = new Node();
			pNode->_value = treeNode->_value;
			pNode->_pNext = NULL;
			vecNode.push_back(pNode);
			tailNodeVector.push_back(pNode);
		}
		else
		{
			Node* pNode = new Node();
			pNode->_value = treeNode->_value;
			pNode->_pNext = NULL;
			Node* tailNode = tailNodeVector.at(height);
			tailNode->_pNext = pNode;
			tailNode = pNode;
			tailNodeVector.at(height) = tailNode; //更新尾结点
		}

		//左子树非空且未访问过，则压入左子树
		if(treeNode->_pLeft && treeNode->_pLeft->_isVisited == false)
		{
			treeNode->_pLeft->_isVisited = true;
			treeNode->_pLeft->_height = height + 1;
			queueTree.push(treeNode->_pLeft);
		}
		if(treeNode->_pRight && treeNode->_pRight->_isVisited == false)
		{
			treeNode->_pRight->_isVisited = true;
			treeNode->_pRight->_height = height + 1;
			queueTree.push(treeNode->_pRight);
		}
	}

	return vecNode;
}

void printResult(vector<Node*>& vecNode)
{
	if(vecNode.empty())
	{
		cout << "List is null!" << endl;
	}
	int size = vecNode.size();
	for(int i = 0 ; i < size ; i++)
	{
		cout << "depth " << (i+1) << ":";
		Node* node = vecNode.at(i);
		while(node)
		{
			cout << node->_value << " ";
			node = node->_pNext;
		}
		cout << ",";
	}
	cout << endl;
}

void releaseList(vector<Node*>& vecNode)
{
	if(vecNode.empty())
	{
		return;
	}
	int size = vecNode.size();
	for(int i = 0 ; i < size ; i++)
	{
		Node* node = vecNode.at(i);
		//删除节点
		while(node)
		{
			Node* tempNode = node;
			node = node->_pNext;
			delete tempNode;
		}
	}
}

void input()
{
	int nodeNum;
	int nodeValue;
	string childNumFlag;
	int leftChild;
	int rightChild;
	while(cin >> nodeNum)
	{
		g_index = 0;
		for(int i = 0 ; i < nodeNum ; i++)
		{
			TreeNode* treeNode = createTreeNode();
			cin >> treeNode->_value;
		}

		//接下来创建结点指向
		for(int i = 1 ; i <= nodeNum ; i++)
		{
			cin >> childNumFlag;
			if("d" == childNumFlag)
			{
				cin >> leftChild >> rightChild;
				g_treeNodeArray[i]._pLeft = &g_treeNodeArray[leftChild];
				g_treeNodeArray[i]._pRight = &g_treeNodeArray[rightChild];
			}
			else if("r" == childNumFlag)
			{
				cin >> rightChild;
				g_treeNodeArray[i]._pRight = &g_treeNodeArray[rightChild];
			}
			else if("l" == childNumFlag)
			{
				cin >> leftChild;
				g_treeNodeArray[i]._pLeft = &g_treeNodeArray[leftChild];
			}
		}

		//下面就是遍历树，创建链表
		vector< Node* > vecNode = visitTreeBFS(&g_treeNodeArray[1]);

		//遍历后打印结果
		printResult(vecNode);
		releaseList(vecNode);
	}
}

int main(int argc , char* argv[])
{
	input();
	getchar();
	return 0;
}