【面试笔试】二叉树相关操作

// 二叉树
// 2015.08.07
//@ author :braveji
/** 二叉树的功能
** 1 建立二叉树 销毁二叉树
** 2 二叉树的遍历：前、中、后，层，分层；递归、非递归；
** 3 二叉树的高度、宽度、叶子节点个数
** 4 将二叉搜索树转换为双链表
** 5 二叉树的镜像
** 6 找出和为指定值的所有路径（后序遍历）
** 7 是否是平衡二叉树（左子树的深度pk右子数的深度）
** 7 相距最远的两个节点的距离（左子树深度+右子树的深度）
** 8 给定两个节点求其最近公共父节点
** 9 判断是否是完全二叉树？
** 10 根据前序和中序遍历重构二叉树
**/

#include <vector>
#include <string>
#include <iostream>
#include <fstream>
#include <queue>
#include <stack>

using namespace std;

//difine Btree
struct Btree
{
	int m_data;
	Btree * m_lchild;
	Btree * m_rchild;
};

// initialization

Btree * initBtree()
{
	return NULL;
}

// build Btree
const int edge = 65535;
fstream fin("init.txt");
int data;
void buildBtree(Btree* &root,fstream &fin)
{
	if(fin >> data)
	{
		//preorder build Btree
		if (data == edge)
		{
			root = NULL;
		}
		else 
		{
			root = new Btree;
			root->m_data = data;
			root->m_lchild = NULL;
			root->m_rchild = NULL;

			buildBtree(root->m_lchild,fin);
			buildBtree(root->m_rchild,fin);
		}
	}
}
Btree * buildBtree()
{
	Btree * root = initBtree();
	buildBtree(root,fin);
	fin.close();
	return root;
}

//traverse tree
//1 preorder recursion
void preOrderBtree(Btree * root,vector<int> & vectorTemp)
{
	if (root)
	{
		cout<<root->m_data<<" ";
		vectorTemp.push_back(root->m_data);
		preOrderBtree(root->m_lchild,vectorTemp);
		preOrderBtree(root->m_rchild,vectorTemp);
	}
}

vector<int> preOrderBtree(Btree * root)
{
// 	if (root)
// 	{
// 		cout<<root->m_data<<" ";
// 		preOrderBtree(root->m_lchild);
// 		preOrderBtree(root->m_rchild);
// 	}
	vector<int> vectorTemp;
	preOrderBtree(root,vectorTemp);
	return vectorTemp;
}
//2 inorder recursion
void inOrderBtree(Btree * root,vector<int> & vectorTemp)
{
	if (root)
	{
		inOrderBtree(root->m_lchild,vectorTemp);
		cout<<root->m_data<<" ";
		vectorTemp.push_back(root->m_data);
		inOrderBtree(root->m_rchild,vectorTemp);
	}
}

vector<int> inOrderBtree(Btree * root)
{
// 	if (root)
// 	{
// 		inOrderBtree(root->m_lchild);
// 		cout<<root->m_data<<" ";
// 		inOrderBtree(root->m_rchild);
// 	}
	vector<int> vectorTemp;
	inOrderBtree(root,vectorTemp);
	return vectorTemp;
}

//3 postorder recursion
void postOrderBtree(Btree *root)
{
	if (root)
	{
		postOrderBtree(root->m_lchild);
		postOrderBtree(root->m_rchild);
		cout<<root->m_data<<" ";
	}
}

// 4 level order
void leverOrderBtree(Btree * root)
{
	queue<Btree*> que;
	if (root)
	{
		que.push(root);
		while(que.size())
		{
			Btree * temp = que.front();
			cout<<temp->m_data<<ends;
			que.pop();
			if (temp->m_lchild) que.push(temp->m_lchild);
			if (temp->m_rchild) que.push(temp->m_rchild);
		}
		cout<<endl;
	}
}

// multi lever order
void multiLeverOrderBtree(Btree * root)
{
	queue<Btree*> que;
	int nextLever=0,toBePrinted=1;//只有上一层遍历完才知道下一层总共有多少个结点需要遍历
	int i=1;
	if (root)
	{
		que.push(root);
		//cout<<"第"<<i<<"层：";
		while(que.size())
		{
			Btree * temp = que.front();
			cout<<temp->m_data<<ends;
			que.pop();
			toBePrinted--;
			if (temp->m_lchild) 
			{
				que.push(temp->m_lchild);
				nextLever++;
			}
			if (temp->m_rchild) 
			{
				que.push(temp->m_rchild);
				nextLever++;
			}
			if (!toBePrinted)
			{
				toBePrinted = nextLever;
				nextLever =0;
				++i;
				cout<<endl;
				//cout<<"第"<<i+1<<"层：";
			}
		}
	}
}

//preorder nonrecursion
void preOrderNonrecurion(Btree * root)
{
	stack<Btree *> stackTemp;
	while(root || stackTemp.size())
	{
		if (root)
		{
			cout<<root->m_data<<ends;
			stackTemp.push(root);
			root = root->m_lchild;
		}
		else
		{
			Btree * temp = stackTemp.top();
			stackTemp.pop();
			root = temp->m_rchild;
		}
	}
	cout<<endl;
}

//inorder nonrecursion
void inOrderNonrecursion(Btree * root)
{
	stack<Btree *> stackTemp;
	while(root || stackTemp.size())
	{
		if (root)
		{
			stackTemp.push(root);
			root = root->m_lchild;
		}
		else
		{
			Btree * temp = stackTemp.top();
			stackTemp.pop();
			cout<<temp->m_data<<ends;
			root = temp->m_rchild;
		}
	}
	cout<<endl;
}

//postorder unrecursion
void postOrderRecursion(Btree * root)
{
	stack<Btree *> stackTemp;
	if (root)
		stackTemp.push(root);
	Btree * cur;
	Btree * prev = NULL;
	while(stackTemp.size())
	{
		cur = stackTemp.top();
		if ((!cur->m_lchild && !cur->m_rchild)||
			(prev &&(prev == cur->m_lchild || prev == cur->m_rchild)))
		{
			cout<<cur->m_data<<ends;
			stackTemp.pop();
			prev = cur;
		}
		else
		{
			if (cur->m_rchild)
				stackTemp.push(cur->m_rchild);
			if (cur->m_lchild)
				stackTemp.push(cur->m_lchild);
		}
	}
	cout<<endl;
}

//deepth 
int deepthBtree(Btree * root)
{
	if (!root)
		return 0;
	int i = deepthBtree(root->m_lchild);
	int j = deepthBtree(root->m_rchild);

	return i>j?i+1:j+1;
}

//leaf number
int leafNumber(Btree * root)
{
	//traverse + leaf
	int leafNum=0;
	stack<Btree *> stackTemp;
	while(root || stackTemp.size())
	{
		while (root)
		{
			if (!root->m_lchild && !root->m_rchild)
				leafNum++;
			stackTemp.push(root);
			root = root->m_lchild;
		}
		if(stackTemp.size())
		{
			Btree * temp = stackTemp.top();
			stackTemp.pop();
			root = temp->m_rchild;
		}
	}
	return leafNum;
}

//width BTree
int widthBtree(Btree * root)
{
	int maxWidth=0;
	int toBeDone =1;
	int count =0;
	queue<Btree*> que;
	if(root)
		que.push(root);
	while(que.size())
	{
		Btree * temp = que.front();
		que.pop();
		if (temp->m_lchild)
		{
			que.push(temp->m_lchild);
			count++;
		}
		if (temp->m_rchild)
		{
			que.push(temp->m_rchild);
			count++;
		}
		toBeDone--;
		if (!toBeDone)
		{
			toBeDone = count;
			if (count > maxWidth) 
				maxWidth = count;
			count=0;
		}
	}
	return maxWidth;
}

//i th level  print
void printILevel(Btree * root,int i)
{
	int deep = deepthBtree(root);
	if (i>deep)
	{
		cout<<"error！！打印的行数超过了树的深度！！"<<endl;
		return;
	}
	queue<Btree *> que;
	int toBeDone =1;
	int nextLevelNum =0;
	int level = 1;
	if (root)
		que.push(root);
	cout<<"只打印第"<<i<<"层: ";
	while(que.size())
	{
		Btree * temp = que.front();
		if (i==level)
			cout<<temp->m_data<<ends;
		if (i+1==level)
			break;
		que.pop();
		if (temp->m_lchild)
		{
			que.push(temp->m_lchild);
			nextLevelNum++;
		}
		if (temp->m_rchild)
		{
			que.push(temp->m_rchild);
			nextLevelNum++;
		}
		toBeDone--;
		if (!toBeDone)
		{
			toBeDone = nextLevelNum;
			nextLevelNum =0;
			level++;
		}
	}
	cout<<endl;
}

//mirror tree
Btree* mirrorBtree(Btree * root)
{
	if (root)
	{
		Btree * temp = root->m_lchild;
		root->m_lchild = root->m_rchild;
		root->m_rchild = temp;
		if (root->m_lchild) mirrorBtree(root->m_lchild);
		if (root->m_rchild) mirrorBtree(root->m_rchild);
	}
	return root;
}

//deepth nonrecursion
int deepthNonRecursion(Btree * root)
{
	//levle order
	int toBeDone =1;
	int nextLevel =0;
	int deep =0;
	queue<Btree*> que;
	if (root)
		que.push(root);
	while(que.size())
	{
		Btree * temp = que.front();
		que.pop();
		if (temp->m_lchild)
		{
			que.push(temp->m_lchild);
			nextLevel++;
		}
		if (temp->m_rchild)
		{
			que.push(temp->m_rchild);
			nextLevel++;
		}
		toBeDone--;
		if (!toBeDone)
		{
			deep++;
			toBeDone = nextLevel;
			nextLevel =0;
		}
	}
	return deep;
}

//balanced Btree
//bool isBalancedBtree(Btree * root)
//{
//	if (!root)
//		return true;
//	int i = deepthBtree(root->m_lchild);
//	int j = deepthBtree(root->m_rchild);
//	if (abs(i-j)>1)
//		return false;
//	else
//		return isBalancedBtree(root->m_lchild) && isBalancedBtree(root->m_rchild);
//}

//测试集1：平衡树  10 6 3 2 65535 65535 4 65535 65535 8 7 65535 65535 9 65535 65535 20 15  12 65535 65535 17 65535 65535 25 22 65535 65535 30 65535 65535
//测试集2：非平衡  10 6 3 2 65535 65535 4 65535 65535 8 7 65535 65535 9 65535 65535 20 65535 65535
bool isBalancedBtree(Btree* root)
{
	stack<Btree*> stackTemp;
	while(root || stackTemp.size())
	{
		while(root)
		{
			int i= deepthBtree(root->m_lchild);
			int j = deepthBtree(root->m_rchild);
			if (abs(i-j)>1)
				return false;
			//if (root->m_lchild)
			//	stackTemp.push(root->m_lchild);//错误原因：加了条件判断
			stackTemp.push(root);
			root = root->m_lchild;
		}
		if (stackTemp.size())
		{
			Btree * temp = stackTemp.top();
			stackTemp.pop();
			root = temp->m_rchild;
		}
	}
	return true;
}

//lowest parent  Binary Search Tree
Btree * lowestParent(Btree * root,Btree* node1,Btree* node2)
{
	if ((root->m_data >= node1->m_data && root->m_data <= node2->m_data) ||
		(root->m_data <= node1->m_data && root->m_data >= node2->m_data))
	{
		return root;
	}
	if (root->m_data < node1->m_data && root->m_data < node2->m_data)
		return lowestParent(root->m_rchild,node1,node2);
	else return lowestParent(root->m_lchild,node1,node2); 
}

//10 6 3 2 65535 65535 4 65535 65535 8 7 65535 65535 9 65535 65535 20 15  12 65535 65535 17 65535 65535 25 22 65535 65535 30 65535 65535
//convert to doublelinklist
// 10 6 3  65535 65535 8 65535 65535  20 15   65535 65535  25  65535 65535
void conver2list(Btree* root,Btree * &prev,Btree * &head,Btree * & last)
{//root 没有引用，prev有引用，
	if (root)
	{
		//last = root;
		if (root->m_lchild)
			conver2list(root->m_lchild,prev,head,last);
		root->m_lchild = prev;//修改了root
		if (prev) prev->m_rchild = root;
		prev = root;
		if (!head)
			head = root;

		if (root->m_rchild)
			conver2list(root->m_rchild,prev,head,last);

	}
// 	if (root->m_lchild)
// 		conver2list(root->m_lchild,prev,head);
// 
// 	root->m_lchild = prev;
// 	if (prev) 
// 		prev->m_rchild = root;
// 	prev = root;
// 	if (!head)
// 		head = root;
// 
// 	if (root->m_rchild)
// 		conver2list(root->m_rchild,prev,head);
}

Btree * conver2list(Btree* root)
{
	Btree * prev = NULL;
	Btree * head = NULL;
	Btree * last = NULL;
	//if (root)
		conver2list(root,prev,head,last);
	return head;
}

// convert to list nonconversion
Btree * convert2ListNonrecursion(Btree * root)
{
	//inorder 
	Btree * prev = NULL;
	Btree * head = NULL;
	stack<Btree *> stackTemp;
	while(root || stackTemp.size())
	{
		while(root)
		{
			stackTemp.push(root);
			root = root->m_lchild;
		}
		if (stackTemp.size())
		{
			Btree * curr = stackTemp.top();
			stackTemp.pop();
			curr->m_lchild = prev;
			if (prev) prev->m_rchild = curr;
			prev = curr;
			if (!head) head = curr;

			//if (curr->m_rchild) root = curr->m_rchild;
			root = curr->m_rchild;
		}
	}
	return head;
}

void printConverList(Btree * root)
{
	cout<<"从小到大："<<ends;
	Btree * temp;
	while(root)
	{
		temp= root;
		cout<<root->m_data<<" ";
		root = root->m_rchild;
	}
	cout<<endl<<"从大到下："<<ends;
	while(temp)
	{
		cout<<temp->m_data<<" ";
		temp  = temp->m_lchild;
	}
	cout<<endl;
}

//destroy list
void destroyList(Btree * head)
{
	Btree * next = head;
	while(head)
	{
		next = head->m_rchild;
		delete head;
		head = NULL;
		head = next;
	}
}

//和为指定值的所有路径
//指定结点的路径(根到结点的路径)
bool pathToNode(Btree * root,Btree * node,vector<Btree *> & stackTemp)
{
	//preorder
	if (!root)
		return false;
	stackTemp.push_back(root);
	if (root == node)
		return true;

	bool found = pathToNode(root->m_lchild,node,stackTemp);
	if (!found) 
		found = pathToNode(root->m_rchild,node,stackTemp);
	if (!found)
		stackTemp.pop_back();
	return found;
}

//找到值为某一值的结点
Btree * findNodeKey(Btree * root,int num)
{
	//front order
	stack<Btree *> stackTemp;
	while(root || stackTemp.size())
	{
		while(root)
		{
			stackTemp.push(root);
			if (root->m_data == num)
			{
				return root;
			}
			root = root->m_lchild;
		}
		if (stackTemp.size())
		{
			Btree * temp = stackTemp.top();
			stackTemp.pop();
			root = temp->m_rchild;
		}
	}
	return NULL;
}

// 非递归 两个结点的最低公共祖先
Btree* lowestParentNorecursion(Btree * root,Btree * node1,Btree * node2)
{
	vector<Btree *> temp1,temp2;
	pathToNode(root,node1,temp1);
	pathToNode(root,node2,temp2);
	int i= temp1.size();
	int j =temp2.size();
	int k=0;
	Btree * parent= root;
	while(k<i && k<j)
	{
		if (temp2[k] == temp1[k])
		{
			parent = temp1[k];
			k++;
		}
		else break;
	}
	return parent;
}

//叶子节点的所有路径
void pathEqualValue(Btree* root,vector<vector<Btree*>> &vectorTemp,vector<Btree*> &temp)
{
	if (!root)
		return ;
	temp.push_back(root);
	if (!root->m_lchild && !root->m_rchild)
	{
		vectorTemp.push_back(temp);
		temp.pop_back();
// 		root = temp[temp.size()-1]->m_rchild;
// 		pathEqualValue(root,num,vectorTemp,temp);
		return ;
	}
	//if(root->m_lchild)
		pathEqualValue(root->m_lchild,vectorTemp,temp);
	//if (root->m_rchild)
		pathEqualValue(root->m_rchild,vectorTemp,temp);
	temp.pop_back();
// 	if (!temp.size())
// 	{
// 		return ;
// 	}
}

//等于给定值的所有路径
void pathEqualValue(Btree* root,int num,int sum,vector<vector<Btree*>> &vectorTemp,vector<Btree*> &temp)
{
	//preorder
	if (!root)
		return;
	sum+= root->m_data;
	temp.push_back(root);
	if (!root->m_lchild && !root->m_rchild)
	{
		if (sum == num)
		{
			vectorTemp.push_back(temp);
			temp.pop_back();
			sum -= root->m_data;
			return;
		}
	}
	pathEqualValue(root->m_lchild,num,sum,vectorTemp,temp);
	pathEqualValue(root->m_rchild,num,sum,vectorTemp,temp);
	temp.pop_back();
	sum -= root->m_data;
}
void pathEqualValue(Btree* root,int num)
{
	vector<vector<Btree*> > vectorTemp,vectorTemp1;
	vector<Btree*> temp,temp1;

	pathEqualValue(root,vectorTemp,temp);
	cout<<"所有叶子节点的路径："<<endl;
	for (unsigned i=0;i<vectorTemp.size();++i)
	{
		temp = vectorTemp[i];
		for (unsigned j=0;j<temp.size();++j)
		{
			cout<<temp[j]->m_data<<" ";
		}
		cout<<endl;
	}

	pathEqualValue(root,num,0,vectorTemp1,temp1);
	cout<<"所有值为"<<num<<"的路径："<<endl;
	for (unsigned i=0;i<vectorTemp1.size();++i)
	{
		temp = vectorTemp1[i];
		for (unsigned j=0;j<temp.size();++j)
		{
			cout<<temp[j]->m_data<<" ";
		}
		cout<<endl;
	}
}

//结点最大距离
int maxLengthBtree(Btree * root)
{
	if (!root)
		return 0;
	int i = deepthBtree(root->m_lchild);
	int j = deepthBtree(root->m_rchild);
	return i+j;
}

//根据前序遍历和中序遍历重构一棵树
Btree * rebuild(vector<int> &preorder,vector<int> &inorder,int preleft,int preright,int inleft,int inright)
{
	if (preright-preleft<0)
	{
		return NULL;
	}
	Btree * root = new Btree;
	root->m_data = preorder[preleft];
	root->m_lchild = NULL;
	root ->m_rchild = NULL;

	int middle =-1;
	for (unsigned i=0;i<inorder.size();++i)
	{
		if (root->m_data == inorder[i])
		{
			middle = i;
			break;
		}
	}

	int d = middle-inleft;

	int preleft1 = preleft +1;
	//int preright1 = middle;
	int preright1 = preleft +d;
	int inleft1 = inleft;
	int inright1 = middle-1;
	root->m_lchild = rebuild(preorder,inorder,preleft1,preright1,inleft1,inright1);

	//int preleft2 = middle+1;
	int preleft2 = preleft +d+1;
	int preright2 = preright;
	int inleft2 = middle+1;
	int inright2 = inright;
	root->m_rchild = rebuild(preorder,inorder,preleft2,preright2,inleft2,inright2);

	return root;
}

Btree * rebuild(vector<int> & preorder,vector<int> & inorder)
{
	int end = preorder.size();
	Btree * root = rebuild(preorder,inorder,0,end-1,0,end-1);
	return root;
}

//判断是否是完全二叉树
bool isCompleteBtree2(Btree * root)
{
	queue<Btree*> queTemp;
	if (root)
		queTemp.push(root);
	while(queTemp.size())
	{
		Btree * temp = queTemp.front();
		queTemp.pop();
		if (temp)
		{
			queTemp.push(temp->m_lchild);
			queTemp.push(temp->m_rchild);
		}
		else
		{
			while(queTemp.size())
			{
				temp = queTemp.front();
				queTemp.pop();
				if (temp)
				{
					return false;
				}
			}
		}
	}
	return true;
}

//是否完全二叉树
bool isCompleteBtree(Btree * root)
{
	queue<Btree*> queueTemp;
	if(root)
		queueTemp.push(root);
	Btree * temp = queueTemp.front();
	while(temp)
	{
		queueTemp.pop();
		queueTemp.push(temp->m_lchild);
		queueTemp.push(temp->m_rchild);
		temp = queueTemp.front();
	}
	while(queueTemp.size())
	{
		temp = queueTemp.front();
		if (temp)
		{
			return false;
		}
		queueTemp.pop();
	}
	return true;
}

//destory Btree
void destroyBtree(Btree * root)
{
	if (root)
	{
		destroyBtree(root->m_lchild);
		destroyBtree(root->m_rchild);
		delete root;
		root = NULL;
	}
}