常见的二叉树面试题

    面试中，最常见是数据结构就是二叉树和链表了，其中和二叉树有关的常见面试题主要是：树的前序遍历、中序遍历、后序遍历、分层遍历、树的节点数、树的叶子节点数、树的第K层节点数、树的深度、树的宽度、平衡二叉树的判定、完全二叉树的判定、满二叉树的判定、由前序中序反推后序遍历、由前序中序重建二叉树，处理这些问题基本思想无外乎是“遍历+递归”。

    关于树的遍历，递归方式太傻太天真，但也是最基本的思想，实现代码网上资料可谓是汗牛充栋，在此就不赘述了。

    下面仅列举了非递归实现树的前序、中序以及后序遍历，由于笔者对代码有洁癖，最不能忍受一个while循环里再嵌套另外一个while循环（网上千篇一律的实现代码方式），虽然二者的思想都是一致的，但笔者的实现方式更为直观易懂，故此处的版本都只借助一个栈、一个while循环：

前序非递归遍历：

void PreOrderTraseNonRecursion(BTree* t)
{
	stack<BNode*> s;
	s.push(t);
	while(!s.empty())
	{
		BNode* p = s.top();
		s.pop();
		Visit(p);
		if(p->rchild)
			s.push(p->rchild);
		if(p->lchild)
			s.push(p->lchild);
	}
}

中序非递归遍历：

void InOrderTraseNonRecursion(BTree* t)
{
	stack<BNode*> s;
	BNode* p=t;
	while(p||!s.empty())
	{
		if(p)
		{
			s.push(p);
			p=p->lchild;
		}
		else
		{
			p = s.top();
			s.pop();
			Visit(p);
			p=p->rchild;
		}
	}
}

前序和中序的非递归遍历都很好理解，我就不再浪费口舌笔墨了，要是真看不懂，请回去把严蔚敏那本《数据结构》再啃一遍、两遍、三遍……要是还看不懂，我只能怀着无比沉重的心情告诉你一个非常不幸的消息：“对不起，你不适合这个行业！”

后序非递归遍历：后序非递归遍历稍微比较难理解些，但是你如果对前序和中序遍历思想已经融会贯通了，其实也就那样：

从根节点开始，只要当前节点存在，或者栈不为空，则重复下面操作： 

(1)从当前节点开始，进栈并走左子树，直到左子树为空。 

(2)如果栈顶节点的右子树为空，或者栈顶节点的右孩子为刚访问过的节点，

   则退栈并访问，然后置当前节点指针为空。

(3)否则走右子树。  

void PostOrderTraseNonRecursion(BTree* t)
{
	stack<BNode*> s;
	BNode* p=t;
	BNode* q=NULL;
	while(p||!s.empty())
	{
		if(p)
		{
			s.push(p);
			p=p->lchild;
		}
		else
		{
			p = s.top();
			if(p->rchild==NULL || p->rchild==q)
			{
				Visit(p);
				s.pop();
				q = p;
				p = NULL;
			}
			else
			{
				p=p->rchild;
			}
		}
	}
}

还有一种网上流传的后序遍历的方式是借助于两个栈，一个栈用来遍历，另一个栈保存遍历到的结点，最后一起出栈，就是后序遍历结果。

void PostOrderTraseNonRecursion2(BTree* t)  
{  
	stack<BNode*> sTraverse,sVisit;  
	BNode* p=NULL;  
	if(t==NULL) 
		return;  
	sTraverse.push(t);  
	while(!sTraverse.empty())  
	{  
		p=sTraverse.top(); 
		sTraverse.pop();  
		sVisit.push(p);  
		if(p->lchild) 
			sTraverse.push(p->lchild);  
		if(p->rchild) 
			sTraverse.push(p->rchild);  
	}  

	while(!sVisit.empty())  
	{  
		p=sVisit.top(); 
		sVisit.pop();  
		Visit(p);
	}  
}

分层遍历：通过分层遍历可实现统计树的深度、每一层节点数、树的最大宽度等要求。基本解法想必你也知道了，就是借助一个队列，进行入队、出队操作，如下面的二叉树，要是一口气全部打印所有节点，即输出：

1 2 3 4 5 6 7。

再进一步考察，如何实现将二叉树按层打印，即每一行打印二叉树的每一层树节点，输出为：

1

2 3 

4 5 6

7

           1
          / \
         2   3
        / \   \
       4   5   6
      /

     7

这就需要再基本的分层遍历基础上再做些手脚了， 下面是一个简单的例子：

//分层打印节点，每一行为一层，返回该二叉树的层数
int DepthTrase(BTree* t)
{
	if(t==NULL)
		return 0;

	vector<BNode*> v;
	v.push_back(t);

	int front=0;//该层的开始节点下标
	int rear=0;//该层结束节点下标
	int last=1;//所有已遍历的节点个数
	int level=0;//层次数

	while(rear < v.size())
	{
		BNode* p = v[rear++];
		if(p->lchild)
			v.push_back(p->lchild);
		if(p->rchild)
			v.push_back(p->rchild);

		if(rear>=last)
		{
			//打印每一层节点
			for(int i=front;i<rear;++i)
			{
				Visit(v[i]);
			}
			cout<<endl;

		        //重置 为下一层遍历准备
			front=rear;
			last=v.size();
			
			level++;
		}
	}
	return level;
}

下面再介绍几个二叉树中的高级应用：

1、根节点到r节点的路径：

   后序遍历时访问到r节点时，栈中的所有的节点均为r节点的祖先，这些祖先构成根节点到r节点的路径。

   由此引出下面的第2个问题……

2、求二叉树中两个节点的最低公共祖先节点：

     递归解法效率很低，有很多重复的遍历，不再赘述。
      非递归解法：先求从根节点到两个节点的路径，然后再比较对应路径的节点，最后一个相同的节点也就是他们在二叉树中的最低公共祖先节点，问题转换为求两个单链表的最后一个公共节点。

3、二叉树节点最大距离

      姑且定义"距离"为两节点之间边的个数。求二叉树中相距最远的两个节点之间的距离，如下图：

      

     http://blog.csdn.net/hxz_qlh/article/details/12996591 对此问题做了详细解答，指出了《编程之美》中其解法的不足之处，并提出了笔者的解法。