编程之美3.9重建二叉树-非递归实现

最新推荐文章于 2020-04-24 16:18:43 发布

原创最新推荐文章于 2020-04-24 16:18:43 发布 · 473 阅读

2 ·

CC 4.0 BY-SA版权

文章标签：

#编程之美 #重建二叉树 #非递归算法

编程算法专栏收录该内容

5 篇文章

订阅专栏

本文详细介绍了如何将递归算法转换为非递归算法，以二叉树的前序遍历为例进行深入探讨。通过对比递归与非递归实现，展示了两种方法的边界条件调整，并提供了完整的代码实现。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

看了书上的递归算法，想转成非递归算法。

模仿前序遍历二叉树的非递归实现。

element结构体的定义见下边的完整代码。

非递归算法：

void ReBuild1(char* pPreOrder, char* pInOrder, int nTreeLen, Node** pRoot) //模仿前序遍历二叉树的非递归算法
{
	element s[TREELEN];
	int top = -1;
	int leftLen;
	if(nTreeLen<=0 || !pPreOrder || !pInOrder)
		return;
	while(top != -1 || nTreeLen>0)
	{
		while(nTreeLen>0)
		{
			Node* pTemp = new Node;
			pTemp->chValue = *pPreOrder;
			pTemp->pLeft = NULL;
			pTemp->pRight = NULL;
			*pRoot = pTemp;
			char* pLeftEnd = pInOrder;
			leftLen = 0;
			while(*pPreOrder != *pLeftEnd)
			{
				leftLen++;
				if(leftLen>nTreeLen)
					return;
				pLeftEnd++;
			}
			top++;
			s[top].pPreOrder = pPreOrder;
			s[top].pInOrder = pInOrder;
			s[top].leftLen = leftLen;
			s[top].len = nTreeLen;
			s[top].pRoot = pRoot;
			pPreOrder++;  //对应ReBuild(pPreOrder+1,pInOrder,leftLen,pRoot->pLeft);
			pRoot = &((*pRoot)->pLeft);
			nTreeLen = leftLen;
		}
		if(top != -1)
		{
			pPreOrder = s[top].pPreOrder;
			pInOrder = s[top].pInOrder;
			leftLen = s[top].leftLen;
			nTreeLen = s[top].len;
			pRoot = s[top].pRoot;
			top--;
			pPreOrder = pPreOrder+leftLen+1; //对应ReBuild(pPreOrder+leftLen+1,pInOrder+leftLen+1,nRightLen,pRoot->pRight);
			pInOrder = pInOrder+leftLen+1;
			nTreeLen = nTreeLen-leftLen-1;
			pRoot = &((*pRoot)->pRight);
		}

	}
}

把书上递归算法的边界条件稍微改了下。

递归算法：

void ReBuild(char* pPreOrder, char* pInOrder, int nTreeLen, Node* &pRoot) //递归 不带返回值
{
	if(nTreeLen <= 0 || !pPreOrder || !pInOrder)
		return;
	Node* pTemp = new Node;
	pTemp->chValue = *pPreOrder;
	pTemp->pLeft = NULL;
	pTemp->pRight = NULL;
	pRoot = pTemp;
	char* pLeftEnd = pInOrder;
	int leftLen = 0;
	while(*pPreOrder != *pLeftEnd)
	{
		leftLen++;
		if(leftLen>nTreeLen)
			return;
		pLeftEnd++;
	}
	int nRightLen = nTreeLen-leftLen-1;
	ReBuild(pPreOrder+1,pInOrder,leftLen,pRoot->pLeft);
	ReBuild(pPreOrder+leftLen+1,pInOrder+leftLen+1,nRightLen,pRoot->pRight);
}

完整的代码：

#include<iostream>
using namespace std;

#define TREELEN 6

struct Node
{
	Node* pLeft;
	Node* pRight;
	char chValue;
};

struct element
{
	char* pPreOrder;
	char* pInOrder;
	int leftLen;
	int len;
	Node** pRoot;
};

void ReBuild(char* pPreOrder, char* pInOrder, int nTreeLen, Node* &pRoot) //递归 不带返回值
{
	if(nTreeLen <= 0 || !pPreOrder || !pInOrder)
		return;
	Node* pTemp = new Node;
	pTemp->chValue = *pPreOrder;
	pTemp->pLeft = NULL;
	pTemp->pRight = NULL;
	pRoot = pTemp;
	char* pLeftEnd = pInOrder;
	int leftLen = 0;
	while(*pPreOrder != *pLeftEnd)
	{
		leftLen++;
		if(leftLen>nTreeLen)
			return;
		pLeftEnd++;
	}
	int nRightLen = nTreeLen-leftLen-1;
	ReBuild(pPreOrder+1,pInOrder,leftLen,pRoot->pLeft);
	ReBuild(pPreOrder+leftLen+1,pInOrder+leftLen+1,nRightLen,pRoot->pRight);
}

void ReBuild1(char* pPreOrder, char* pInOrder, int nTreeLen, Node** pRoot) //模仿前序遍历二叉树的非递归算法
{
	element s[TREELEN];
	int top = -1;
	int leftLen;
	if(nTreeLen<=0 || !pPreOrder || !pInOrder)
		return;
	while(top != -1 || nTreeLen>0)
	{
		while(nTreeLen>0)
		{
			Node* pTemp = new Node;
			pTemp->chValue = *pPreOrder;
			pTemp->pLeft = NULL;
			pTemp->pRight = NULL;
			*pRoot = pTemp;
			char* pLeftEnd = pInOrder;
			leftLen = 0;
			while(*pPreOrder != *pLeftEnd)
			{
				leftLen++;
				if(leftLen>nTreeLen)
					return;
				pLeftEnd++;
			}
			top++;
			s[top].pPreOrder = pPreOrder;
			s[top].pInOrder = pInOrder;
			s[top].leftLen = leftLen;
			s[top].len = nTreeLen;
			s[top].pRoot = pRoot;
			pPreOrder++;  //对应ReBuild(pPreOrder+1,pInOrder,leftLen,pRoot->pLeft);
			pRoot = &((*pRoot)->pLeft);
			nTreeLen = leftLen;
		}
		if(top != -1)
		{
			pPreOrder = s[top].pPreOrder;
			pInOrder = s[top].pInOrder;
			leftLen = s[top].leftLen;
			nTreeLen = s[top].len;
			pRoot = s[top].pRoot;
			top--;
			pPreOrder = pPreOrder+leftLen+1; //对应ReBuild(pPreOrder+leftLen+1,pInOrder+leftLen+1,nRightLen,pRoot->pRight);
			pInOrder = pInOrder+leftLen+1;
			nTreeLen = nTreeLen-leftLen-1;
			pRoot = &((*pRoot)->pRight);
		}

	}
}

Node* ReBuild2(char* pPreOrder, char* pInOrder, int nTreeLen) //递归 带返回值
{
	if(nTreeLen<=0 || !pPreOrder || !pInOrder)
		return NULL;
	Node* pTemp = new Node;
	pTemp->chValue = *pPreOrder;
	int leftLen = 0;
	char* pEnd = pInOrder;
	while(*pPreOrder != *pEnd)
	{
		leftLen++;
		pEnd++;
		if(leftLen > nTreeLen)
			return NULL;
	}
	int rightLen = nTreeLen - leftLen - 1;
	pTemp->pLeft = ReBuild2(pPreOrder+1,pInOrder,leftLen);
	pTemp->pRight = ReBuild2(pPreOrder+leftLen+1,pEnd+1,rightLen);
	return pTemp;
}

void PreOrder(Node* root)
{
	if(root == NULL) return;
	cout<<root->chValue<<endl;
	PreOrder(root->pLeft);
	PreOrder(root->pRight);
	delete root;  //释放内存
}

int main()
{
	char preOrder[TREELEN]={'a','b','d','c','e','f'};
	char inOrder[TREELEN]={'d','b','a','e','c','f'};
	Node* pRoot = NULL;
	ReBuild(preOrder,inOrder,TREELEN,pRoot);
	PreOrder(pRoot); //释放内存
	cout<<"************************"<<endl;
	ReBuild1(preOrder,inOrder,TREELEN,&pRoot);
	PreOrder(pRoot); //释放内存
	cout<<"************************"<<endl;
	pRoot = ReBuild2(preOrder,inOrder,TREELEN);
	PreOrder(pRoot); //释放内存
	system("pause");
	return 0;
}