前序和中序重建二叉树，树的前序递归，中序递归，后序递归遍历和前序非递归，中序非递归，后序非递归遍历

最新推荐文章于 2025-02-21 23:04:46 发布

nothing is worse

最新推荐文章于 2025-02-21 23:04:46 发布

阅读量511

点赞数

CC 4.0 BY-SA版权

分类专栏： c/c++ 面试题目文章标签：前序非递归中序非递归后序非递归遍历重建二叉树

本文链接：https://blog.youkuaiyun.com/small_small_chick/article/details/10284161

c/c++ 同时被 2 个专栏收录

72 篇文章

订阅专栏

面试题目

30 篇文章

订阅专栏

本文详细介绍了C++中利用非递归方式实现二叉树的前序、中序、后序遍历，并通过递归方式重建二叉树的方法，适合对数据结构和算法感兴趣的读者。

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

#include <iostream>
#include <stack>
using namespace std;

int preOrder[] = {10, 6, 4, 8, 14, 12, 16};
int inOrder[] =  {4, 6, 8, 10, 12, 14, 16};

//int preOrder[] = {1, 2, 3, 4,5 , 6};
//int inOrder[] =  {1, 2, 3, 4, 5, 6};

typedef struct Node_
{
	Node_ * left, * right;
	int data;
	bool visit;
}Node;

//递归前序遍历
void preTraverse(Node * root)
{
	if(!root)
	{
		return;
	}

	printf("%d ", root->data);
	preTraverse(root->left);
	preTraverse(root->right);
}

//递归中序遍历
void InOrderTraverse(Node * root)
{
	if(!root)
	{
		return;
	}


	InOrderTraverse(root->left);
	printf("%d ", root->data);
	InOrderTraverse(root->right);
}

//递归后序遍历
void PostOrderTraverse(Node * root)
{
	if(!root)
	{
		return;
	}

	PostOrderTraverse(root->left);
	PostOrderTraverse(root->right);
	printf("%d ", root->data);
}

//非递归中序排序
void NonRecursionInOrder(Node * root)
{
	if(!root)
	{
		return;
	}
	stack<Node*> st;
	st.push(root);

	while(!st.empty())
	{
		Node * top = st.top();
		while( top)
		{
			st.push(top->left);
			top  = top->left;
		}

		Node * tmpRoot = 0;
		st.pop();

		if(!st.empty())
		{
			 tmpRoot = st.top();
			 st.pop();

			printf("%d ", tmpRoot->data);
			st.push(tmpRoot->right);

		}
	}

}

//非递归前序排序
void NonRecursionPreOrder(Node * root)
{
	if (!root)
	{
		return;
	}

	stack<Node *> st;
	st.push(root);
	while(!st.empty())
	{
		Node * cur = st.top();
		if (cur)
		{
			printf("%d ", cur->data);
			while(cur && cur->left)
			{

				cur = cur->left;
				st.push(cur);
				printf("%d ", cur->data);
			}

		}
		else
		{
			st.pop(); 
		}
		
		if(!st.empty())
		{
			cur = st.top(); st.pop();
			st.push(cur->right);
		}
		
	}
}


//非递归后序排序
void NonRecursionPostOrder(Node * root)
{
	if (!root)
	{
		return;
	}

	stack<Node * > st;
	st.push(root);
	root->visit = false;

	while(!st.empty())
	{

		Node * cur = st.top();
		if(cur->visit == true)
		{
			printf("%d ",cur->data);
			st.pop();
		}
		else
		{

			if (cur->visit == false)
			{
				cur->visit = true;
			}

			if (cur->right)
			{
				cur->right->visit = false;
				st.push(cur->right);
			}

			if(cur->left)
			{
				cur->left->visit = false;
			
				st.push(cur->left);
			}
		}

	
	}

}

Node * RebuildBTree(Node * & root, int n, int pl, int pr, int il, int ir)
{
	int i = 0;

	for (i = il;i <= ir; ++i)
	{
		if (inOrder[i] == preOrder[pl])
		{
			break;
		}
	}
	int k = i - il;
	if (i <= ir)
	{
		root = new Node();
		root->data = inOrder[i];
	}
	else
	{
		root = NULL;
		return root;
	}
	root->left = RebuildBTree(root->left, k,pl + 1 ,pl + k , il, i-1);
	root->right = RebuildBTree(root->right,ir - i ,pl + k + 1,pr, i+1, ir);

	return root;
}

int main()
{
	Node * root = 0;
	int n = 7;
	int pl = 0, pr = 6;
	int il = 0, ir = 6;
	root = RebuildBTree(root, n, pl, pr, il,ir);

	printf("前序递归：");
	preTraverse(root);

	printf("\r\n");
	printf("中序递归：");
	InOrderTraverse(root);

	printf("\r\n");
	printf("后序递归：");
	PostOrderTraverse(root);
	
	printf("\r\n前序非递归：");
	NonRecursionPreOrder(root);

	printf("\r\n");
	printf("中序非递归：");
	NonRecursionInOrder(root);

	printf("\r\n后序非递归：");
	NonRecursionPostOrder(root);
	return 0;
}