Binary Tree Level Order Traversal

初阶：

Given a binary tree, return the level order traversal of its nodes’ values. (ie, from left to right, level by
level).
For example: Given binary tree {3,9,20,#,#,15,7},
3
/ \
9 20
/ \
15 7
return its level order traversal as:
[
[3],
[9,20],
[15,7]
]

进阶。

Given a binary tree, return the bottom-up level order traversal of its nodes’ values. (ie, from left to right,
level by level from leaf to root).
For example: Given binary tree {3,9,20,#,#,15,7},
3
/ \
9 20
/ \
15 7
return its bottom-up level order traversal as:

[
[15,7]
[9,20],
[3],
]

进阶2。

Binary Tree Zigzag Level Order Traversal

Given a binary tree, return the zigzag level order traversal of its nodes’ values. (ie, from left to right,
then right to left for the next level and alternate between).
For example: Given binary tree 3,9,20,#,#,15,7,
3
/ \
9 20
/ \
15 7
return its zigzag level order traversal as:
[
[3],
[20,9],
[15,7]
]

思路：

有两种方式实现，一个是采用队列来模拟实现。另外一种是采用递归。

先看一种：

//如果不考虑层次，只用一个vec表示，比较简单。
vector<char> leverOrder2(TreeNode *root)
{
	vector<char> result;
	if(root == NULL)
		return result;
	queue<TreeNode*> q;
	q.push(root);

	while(!q.empty())
	{
		TreeNode *node = q.front();
		q.pop();
		result.push_back(node->data);

		if(node->left != NULL)
			q.push(node->left);
		if(node->right != NULL)
			q.push(node->right);
	}

	return result;
}

//如果考虑层次，需要用vec<vec<char>>来记录。
vector<vector<char>> leverOrder3(TreeNode *root)
{
	vector<vector<char>> result;
	if(root == NULL)
		return result;

	queue<TreeNode *> q;
	q.push(root);
	vector<char> tmp;
	int count = 1;
	while(!q.empty())
	{
		tmp.clear();
		int levelCount = 0;
		for(int i=0;i<count;i++)//遍历当前层的所有节点
		{
			TreeNode *node = q.front();
			q.pop();
			tmp.push_back(node->data);
			//同一层的左右子节点也在同一层上，将新一层的节点插入到队列中
			if(node->left != NULL)
			{
				q.push(node->left);
				++levelCount; //计算新一层的节点数目
			}
			if(node->right != NULL)
			{
				q.push(node->right);
				++levelCount; //计算新一层的节点数目
			}
		}
		count = levelCount;//得出新的一层的节点数目
		result.push_back(tmp);
	}
	return result;
}

在看用递归来实现：

#include <iostream>
#include <vector>
using namespace std;

struct TreeNode{
	char data;
	TreeNode *left;
	TreeNode *right;
	TreeNode(char x) : data(x), left(NULL), right(NULL) {}
};

//思路。采用递归的方式。用一个二维数组表示,一维表示层，另外一维表示当前层的值。
void levelOrder(vector<vector<char>> &ret,int dep,TreeNode *root)
{	
	if(root == NULL)
	{
		return;
	}

	if(ret.size()>dep)//如果层数大于树的深度时
	{
		ret[dep].push_back(root->data);
	}
	else
	{
		vector<char> a;
		a.push_back(root->data);
		ret.push_back(a);
	}

	levelOrder(ret,dep+1,root->left);
	levelOrder(ret,dep+1,root->right);
}

//采用递归的方式，和上面的区别在于，加一个flag记录是从左到右还是从右到左，每一层结束翻转一下
void zigzagLevelOrder(vector<vector<char>> &ret,int dep,TreeNode *root,bool left_to_right)
{
	if(!root) return;
	
	if(ret.size()>dep)
	{
		if(left_to_right)
		{
			ret[dep].push_back(root->data);
		}
		else
		{
			ret[dep].insert(ret[dep].begin(),root->data);
		}
	}
	else
	{
		vector<char> a;
		a.push_back(root->data);
		ret.push_back(a);
	}
	zigzagLevelOrder(ret,dep+1,root->left,!left_to_right);
	zigzagLevelOrder(ret,dep+1,root->right,!left_to_right);
}

//创建一个二叉树
void buildTree2(TreeNode **T)
{
	char ch;
	cin>>ch;
	if(ch == '#')
	{
		*T = NULL;
	}
	else
	{
		*T = new TreeNode(ch);
		printf("请输入%c的左孩子：",ch);
		buildTree2(&((*T)->left));
		printf("请输入%c的右孩子：",ch);
		buildTree2(&((*T)->right));
	}
}


//先序遍历
void preTraverse(TreeNode *root)
{
	if(root == NULL) return;
	printf("%c ",root->data);
	if(root->left) preTraverse(root->left);
	if(root->right) preTraverse(root->right);	
}

void main()
{
	TreeNode *T;
	buildTree2(&T);
	vector<vector<char>> ret;
	//levelOrder(ret,0,T);
	zigzagLevelOrder(ret,0,T,true);
	for(int i=0;i<ret.size();i++)
	{
		vector<char> a = ret[i];
		for(int j=0;j<a.size();j++)
		{
			printf("%c ",a[j]);
		}
		printf("\n");
	}
	//preTraverse(T);
	//printf("\n");
}