二叉树递归非递归实现

 直接上程序

#include <iostream>
#include<stack>
#include<stdlib.h>
 
using namespace std;

const int  len= 5;

typedef struct TreeNode  //定义一个二叉树结构
{
	int data;
	struct TreeNode* left;
	struct TreeNode* right;
} *BinTree;

// 向下遍历，找到结点s应该插入的位置，结点有重复时，忽略这个节点
void serachTreeNode(BinTree &root,BinTree &s)
{
	if (root == NULL)
		return;
	if (s->data > root->data) //s值大于根结点，未到达叶子结点，继续往右遍历
	{
		if (root->right == NULL)
		{
			root->right = s;
			return;
		}
		serachTreeNode(root->right, s);
	}
	else if (s->data < root->data)

	{
		if (root->left == NULL)
		{
			root->left = s;
			return;
		}
		serachTreeNode(root->left, s);
	}
	else
		;

}
// 插入一个结点，树为空，插入即为根结点，否则找合适的位置插入
void Insert(BinTree &tree, BinTree &s)
{
	if (tree == NULL)
		tree = s;
	else
		serachTreeNode(tree, s);
}

//二叉排序树创建，每次增加一个结点，插到现有的二叉树上
void creatOrderBintree(BinTree &tree,int *a )
{
	for (int i = 0; i < len; i++)
	{
		BinTree s = (BinTree)malloc(sizeof(TreeNode));
		s->data = a[i];
		s->left =NULL;
		s->right = NULL;
		Insert(tree, s);
	}

}

//1.前序遍历

//(1)递归实现
void preOrderTraversal(BinTree & tree)
{
	if (tree != NULL)
	{
		cout << tree->data <<"->"; //先把根结点打印出
		
		preOrderTraversal(tree->left);//左子树遍历
	
		preOrderTraversal(tree->right); //右子树遍历
	}
	else
		return;
}

//(2)非递归实现 ，非递归实现借助栈实现
void preOrderTraversal1(BinTree & tree)
{
	BinTree T = tree;
	if (tree == NULL)
		return;
	stack <BinTree> s;
	while (T != NULL || !s.empty()) // 树不空或者栈为空
	{
		while (T!=NULL)
		{
			cout << T->data << "->";
			s.push(T);
			T = T->left;
		}
		if (!s.empty())
		{
			T = s.top();
			s.pop();
			T = T->right;
		}
	}
}


//2.中序遍历
//（1） 递归实现  The recursive implementation
void midOrderTraversal(BinTree &tree)
{
	if (tree == nullptr)
		return;
	midOrderTraversal(tree->left);
	cout << tree->data << "->";
	midOrderTraversal(tree->right);
}

//(2)非递归实现 Non-recursive implementation
void midOrderTraversa1(BinTree &tree)
{
	if (tree == nullptr)
		return;
	BinTree T = tree;
	stack <BinTree> s;
	while (T != nullptr || !s.empty())
	{
		while (T != nullptr)
		{
			s.push(T);
			T = T->left;
		}
		if (!s.empty())
		{
			T = s.top();
			cout << T->data << "->";
			s.pop();
			T = T->right;

		}
	}
	
}

//后序遍历 
// （1）递归实现

void finalOrderTraversal(BinTree&tree)
{
	if (tree == nullptr)
		return;
	finalOrderTraversal(tree->left);
	finalOrderTraversal(tree->right);
	cout << tree->data << "->";

}

//（2）非递归实现
void finalOrderTraversal1(BinTree&tree)
{
	if (tree == nullptr)
		return;
	BinTree curr = tree, pre = nullptr;
	stack<BinTree> s;
	s.push(tree);
	while (!s.empty())
	{
		curr = s.top();
		if ((curr->left == NULL && curr->right == NULL) || ((pre == curr->left || pre == curr->right) && pre != nullptr))
		{
			cout << curr->data << "->";
			s.pop();
			pre = curr;
		}
		else
		{
			if (curr->right != nullptr)
				s.push(curr->right);
			if (curr->left != nullptr)
				s.push(curr->left);

		}

	}

	

}

int main()
{
	int a[len] = { 5,4,3,2,1 };
	BinTree tree=NULL;

	creatOrderBintree(tree, a);

	cout << "前序遍历"<<endl;
	preOrderTraversal(tree);
	cout << endl;
	preOrderTraversal1(tree);
	cout << endl << endl;

	cout << "中序遍历" << endl;
	midOrderTraversal(tree);
	cout << endl;
	midOrderTraversa1(tree);
	cout << endl << endl;

	cout << "后序遍历" << endl;
	finalOrderTraversal1(tree);
	cout << endl;
	finalOrderTraversal1(tree);
	cout << endl << endl;
	system("pause");

	return 0;
}