二叉樹遍歷求差值絕對值最大值

來自阿里巴巴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;
}

測試結果：