常见的二叉树面试题大汇总（涵盖二叉搜索树）

源代码

1，前序遍历建立二叉树

2，前序遍历

3，中序遍历

4，后序遍历

5，二叉树的销毁

6，从上至下分层遍历二叉树

7，从上至下分层遍历二叉树 且每一层打印一行

求二叉树的宽度，思路一直。

8，按照之字形上至下分层 打印二叉树

9，求二叉树深度

10，判断是否是平衡二叉树

11，判断是否是平衡二叉树 不允许重复遍历

12，求二叉树第K层的节点数

13，求二叉树第K层叶子节点数

14，比较两个二叉树结构是否相同，不涉及存储的数据

15，求二叉树镜像

16，判断二叉树是否对称

17，查找二叉树中两个节点的最低祖先节点（或最近公共父节点等）

18，求父节点与子节点之间的距离

19，二叉树中任意两个节点之间的距离

20，二叉搜索树的查找

21，二叉搜索树的插入

22，二叉排序树的节点删除

#include <iostream>
#include <vector>
#include <stdlib.h>
#include <queue>
#include <algorithm>
#include <stack>

using namespace std;


typedef struct BTree
{
	int value;
	struct BTree *pLeft;
	struct BTree *pRight;

}BTree;

/*
前序遍历建立二叉树，0代表NULL
{1,2,4,8,0,0,9,0,0,5,0,0,3,6,0,0,9,0,0}
*/
BTree *CreateBTree(BTree * node,int *num,int &index)
{
	if (num[index] ==  0 )
	{
		return NULL;
	}
	else
	{
		node = new BTree;
		node->value = num[index];
		node->pLeft = CreateBTree(node->pLeft,num,++index);
		node->pRight = CreateBTree(node->pRight,num,++index );
	}
	return node;
}


void Visit(BTree *node)
{
	cout<<node->value<<ends;
}

/*
前序遍历
定义：  先访问根节点，在访问左子树，最后访问右子树；
*/
void  PreorderTraverse( BTree *pRoot)
{  
	if( pRoot == NULL )  
		return ;  

	Visit( pRoot);  

	PreorderTraverse( pRoot->pLeft );  
	PreorderTraverse( pRoot->pRight);  
}  


/*
根据前序遍历访问的顺序，优先访问根结点，然后再分别访问左孩子和右孩子。即对于任一结点，其可看做是根结点，
因此可以直接访问，访问完之后，若其左孩子不为空，按相同规则访问它的左子树；当访问其左子树时，再访问它的右子树。因此其处理过程如下：

对于任一结点P：

1)访问结点P，并将结点P入栈;

2)判断结点P的左孩子是否为空，若为空，则取栈顶结点并进行出栈操作，并将栈顶结点的右孩子置为当前的结点P，循环至1);
若不为空，则将P的左孩子置为当前的结点P;

3)直到P为NULL并且栈为空，则遍历结束。
*/

void preOrder2(BTree *root)     //非递归前序遍历 
{
	stack<BTree*> s;
	BTree *p=root;
	while(p!=NULL||!s.empty())
	{
		while(p!=NULL)
		{
			cout<<p->value<<" ";
			s.push(p);
			p=p->pLeft;
		}
		if(!s.empty())
		{
			p=s.top();
			s.pop();
			p=p->pRight;
		}
	}
}
/*
中序遍历
定义：首先访问左子树，然后访问根节点，最后访问右子树
*/
void  InorderTraverse( BTree *pRoot)
{  
	if( pRoot == NULL )  
		return ;  

	InorderTraverse( pRoot->pLeft ); 
	Visit( pRoot);  
	InorderTraverse( pRoot->pRight);  
}  
/*
非递归实现

根据中序遍历的顺序，对于任一结点，优先访问其左孩子，而左孩子结点又可以看做一根结点，然后继续访问其左孩子结点，
直到遇到左孩子结点为空的结点才进行访问，然后按相同的规则访问其右子树。因此其处理过程如下：

对于任一结点P，

1)若其左孩子不为空，则将P入栈并将P的左孩子置为当前的P，然后对当前结点P再进行相同的处理；

2)若其左孩子为空，则取栈顶元素并进行出栈操作，访问该栈顶结点，然后将当前的P置为栈顶结点的右孩子；

3)直到P为NULL并且栈为空则遍历结束

*/
void inOrder2(BTree *root)      //非递归中序遍历
{
	stack<BTree*> s;
	BTree *p=root;
	while(p!=NULL||!s.empty())
	{
		while(p!=NULL)
		{
			s.push(p);
			p=p->pLeft;
		}
		if(!s.empty())
		{
			p=s.top();
			cout<<p->value<<" ";
			s.pop();
			p=p->pRight;
		}
	}    
}
/*
后序遍历
定义： 给定根节点，首先遍历左子树，然后遍历右子树，最后遍历根节点
*/
void  PostorderTraverse( BTree *pRoot)
{  
	if( pRoot == NULL )  
		return ;  

	PostorderTraverse( pRoot->pLeft ); 	
	PostorderTraverse( pRoot->pRight);  
	Visit( pRoot);  
} 

/*
要保证根结点在左孩子和右孩子访问之后才能访问，因此对于任一结点P，先将其入栈。如果P不
存在左孩子和右孩子，则可以直接访问它；或者P存在左孩子或者右孩子，但是其左孩子和右孩子
都已被访问过了，则同样可以直接访问该结点。若非上述两种情况，则将P的右孩子和左孩子依次
入栈，这样就保证了每次取栈顶元素的时候，左孩子在右孩子前面被访问，左孩子和右孩子都在
根结点前面被访问。
*/
void postOrder3(BTree *root)     //非递归后序遍历
{
	stack<BTree*> s;
	BTree *cur;                      //当前结点 
	BTree *pre=NULL;                 //前一次访问的结点 
	s.push(root);
	while(!s.empty())
	{
		cur=s.top();
		if((cur->pLeft==NULL&&cur->pRight==NULL)||
			(pre!=NULL&&(pre==cur->pLeft||pre==cur->pRight)))
		{
			cout<<cur->value<<" ";  //如果当前结点没有孩子结点或者孩子节点都已被访问过 
			s.pop();
			pre=cur; 
		}
		else
		{
			if(cur->pRight!=NULL)
				s.push(cur->pRight);
			if(cur->p