二叉树建立，递归，非递归，前序，中序，后序遍历

最新推荐文章于 2020-01-15 11:27:29 发布

hodd1988

最新推荐文章于 2020-01-15 11:27:29 发布

阅读量618

点赞数

分类专栏：算法文章标签：二叉树建立递归非递归遍历

本文链接：https://blog.csdn.net/hodd1988/article/details/42457037

版权

算法专栏收录该内容

17 篇文章 0 订阅

订阅专栏

#include <cstring>
#include <iostream>
#include <stack>
#include <iomanip>
using namespace std;
struct TreeNode
{
	int data;
	TreeNode* left;
	TreeNode* right;
}; // end of TreeNode
// 前序遍历建立二叉树,0表示空节点
void createTree(TreeNode** root, int** nodeArr, int* size)
{
	// 验证数据有效性
	if(root == NULL || nodeArr == NULL || *nodeArr == NULL 
			|| size == NULL || *size == 0)
	{
		return;
	}
	// 当前节点非空
	if(**nodeArr != 0)
	{
		TreeNode* pNode = new TreeNode;
		pNode->data = **nodeArr;
		pNode->left = NULL;
		pNode->right = NULL;
		*root = pNode;

		++(*nodeArr);
		--(*size);

		// 递归建立左子树
		createTree(&(*root)->left, nodeArr, size);
		// 递归建立右子树
		createTree(&(*root)->right, nodeArr, size);
	}
	else
	{
		++(*nodeArr);
		--(*size);
	}
}
void visit(TreeNode* node)
{
	cout << node->data << '\t';
}
// 递归前序遍历
void preOrderTraverse(TreeNode* root)
{
	if(root != NULL)
	{
		visit(root);
		preOrderTraverse(root->left);
		preOrderTraverse(root->right);
	}
}
// 非递归前序遍历
void nonRecursivePreOrder(TreeNode* root)
{
	if(root == NULL)
	{
		return;
	}
	TreeNode* p = root;
	stack<TreeNode*> s; // 栈中每个节点的右子树都还未遍历过
	while(p != NULL || !s.empty())
	{
		while(p != NULL)
		{
			visit(p);
			s.push(p);
			p = p->left;
		}
		p = s.top();
		s.pop();
		p = p->right;
	}
}
// 递归中序遍历
void inOrderTraverse(TreeNode* root)
{
	if(root != NULL)
	{
		inOrderTraverse(root->left);
		visit(root);
		inOrderTraverse(root->right);
	}
}
// 非递归中序遍历
void nonRecursiveInOrder(TreeNode* root)
{
	if(root == NULL)
	{
		return;
	}
	TreeNode* p = root;
	stack<TreeNode*> s; // 栈中每个节点的右子树都还未遍历过
	while(p != NULL || !s.empty())
	{
		while(p != NULL)
		{
			s.push(p);
			p = p->left;
		}
		p = s.top();
		visit(p);
		s.pop();
		p = p->right;
	}
}
// 递归后序遍历
void postOrderTraverse(TreeNode* root)
{
	if(root != NULL)
	{
		postOrderTraverse(root->left);
		postOrderTraverse(root->right);
		visit(root);
	}
}
// 非递归后序遍历
void nonRecursivePostOrder(TreeNode* root)
{
	if(root == NULL)
	{
		return;
	}
	TreeNode* p = root;
	TreeNode* preVisit = NULL; // 遍历的前一个非空节点
	stack<TreeNode*> s;
	while(p != NULL || !s.empty())
	{
		while(p != NULL)
		{
			s.push(p);
			p = p->left;
		}
		p = s.top();
		// 没有右子树或者刚从右子树返回
		if(p->right == NULL || preVisit == p->right)
		{
			visit(p);
			s.pop();
			preVisit = p;
			p = NULL;
		}
		else
		{
			p = p->right;
		}
	}
}
int main(int argc, char* argv[])
{
	int arr[] = {1, 2, 3, 0, 0, 4, 5, 0, 6, 0, 0, 7, 0, 0, 0,};
	int size = sizeof(arr) / sizeof(int);
	int* nodeArr = arr;
	TreeNode* root = NULL;
	createTree(&root, &nodeArr, &size);
	cout << setw(15) << "递归前序:";
	preOrderTraverse(root);
	cout << endl;
	cout << setw(15) << "非递归前序:";
	nonRecursivePreOrder(root);
	cout << endl;
	cout << setw(15) << "递归中序:";
	inOrderTraverse(root);
	cout << endl;
	cout << setw(15) << "非递归中序:";
	nonRecursiveInOrder(root);
	cout << endl;
	cout << setw(15) << "递归后序:";
	postOrderTraverse(root);
	cout << endl;
	cout << setw(15) << "非递归后序:";
	nonRecursivePostOrder(root);
	cout << endl;
	return 0;
}