二叉树遍历求差值绝对值最大值

来自阿里巴巴2015年笔试题，参考牛客网。

写一个函数，输入一个二叉树，树中每个节点存放了一个整数值，函数返回这颗二叉树中相差最大的两个节点间的差值绝对值。请注意程序效率。

这道题目可以通过遍历整个二叉树，求解二叉树中最大值和最小值，最后算出最大的差值。

可以定义一个二叉树，如下图。

初始化二叉树结点、链接结点、二叉树的结构的定义

struct BinTree
{
	int data;
	BinTree * lchild;
	BinTree * rchild;
};
BinTree * createnode(int val)
{
	BinTree * node=new BinTree;
	node->data=val;
	node->lchild=NULL;
	node->rchild=NULL;
	return node;
}
void connectnode(BinTree * f,BinTree * lchild,BinTree *rchild)
{
	if(f==NULL)
		return ;
	f->lchild=lchild;
	f->rchild=rchild;
}

对于二叉树可以按层遍历，图中二叉树按层遍历的结果为1 2 3 4 5 6 7。

二叉树按层遍历，可以利用STL队列。

int find_max_diff1(BinTree* head)//按层遍历
{
	queue<BinTree*> q;
	BinTree* p;
	if (NULL==head)
	{
		return -1;
	}
	int max1=INT_MIN;//初始化最大值
	int min1=INT_MAX;//初始化最小值
	q.push(head);
	while (!q.empty())
	{
		p = q.front();
		q.pop();
		if(p->data>max1)
			max1=p->data;
		if(p->data<min1)
			min1=p->data;
		if (p->lchild!=NULL)
		{
			q.push(p->lchild);
		}
		if (p->rchild!=NULL)
		{
			q.push(p->rchild);
		}
	}
	return (max1-min1);
}

当输入的head指针为NULL,表明二叉树为空，返回-1代表输入参数异常。

除了按层遍历外，使用的最多的要数先序遍历。先序遍历先输出二叉树的根结点，再分别对根节点的左子树与右子树进行相同的操作，既可以用递归的方式实现，也可以用循环的方式实现。

以递归的方式实现二叉树遍历：

先定义两个全局变量，min1、max1。通过函数递归的过程，来修改min1、max1的数值，最后函数find_max_diff2返回max1-min1。

int min1=INT_MAX;//全局变量
int max1=INT_MIN;
void midprint(BinTree * head)//递归先序遍历
{
	
	if(head==NULL)
		return;
	if(head->data> max1)
		max1=head->data;
	if(head->data<min1)
		min1=head->data;
	midprint(head->lchild);
	midprint(head->rchild);
}
int find_max_diff2(BinTree * head)
{
	if(head==NULL)//当输入空指针
		return -1;
	midprint(head);
	return max1-min1;
}

以循环的方式现实二叉树遍历。

int find_max_diff3(BinTree *head)//先序遍历循环
{
    stack<BinTree*> s;
    BinTree *p=head;
	if(head==NULL)
		return -1;
    int max1 = p->data;
    int min1 = p->data;
    while(p!=NULL||!s.empty())
    {
        while(p!=NULL)
        {
            s.push(p);
            p=p->lchild;
        }
        if(!s.empty())
        {
            p=s.top();
			//cout<<p->data<<" ";
            if(p->data > max1)
            {
                max1 = p->data;
            }
            if(p->data < min1)
            {
                min1 = p->data;
            }
            s.pop();
            p=p->rchild;
        }
 }
 return abs(max1 - min1);
 }

测试程序：

int main()
{
	BinTree *node1=createnode(1);
	BinTree *node2=createnode(2);
	BinTree *node3=createnode(3);
	BinTree *node4=createnode(4);
	BinTree *node5=createnode(5);
	BinTree *node6=createnode(6);
	BinTree *node7=createnode(7);
	connectnode(node1,node2,node3);
	connectnode(node2,node4,node5);
	connectnode(node3,node6,node7);
	cout<<find_max_diff1(node1)<<endl;
	cout<<find_max_diff2(node1)<<endl;
	
	cout<<find_max_diff3(node1)<<endl;
	return 0;
}

测试结果：