完全二叉树的生成，以及前中后序遍历（递归或者非递归都有）（C++类实现）

#include<stdio.h>
#include<stdlib.h>
#include<stack>
#include<queue>
using namespace std;
struct Data
{
	int id;
};
struct Node
{
	Data data;//数据
	bool isprint = 0;//后序非递归判断是否被打印
	Node* left;//左孩子
	Node* right;//右孩子
	Node* prev;//父亲
	
};
stack <Node> s;
struct BinTree 
{
//方法
	bool isEmpty()
	{
		if (head)
		{
			return 0;
		}
		else
		{
			return 1;
		}
	}
	//插入节点(生成完全二叉树)
	void Insert(Data* data)
	{
		if (!head)
		{
			Node* temp = new Node();
			temp->data = *data;
			temp->left = NULL;
			temp->right = NULL;
			head = temp;
			deep++;
			ct_node++;
			return;
		}
		flag = 0;
		Preorder_traversal(this->head);//找到当前应该插入的非空的节点
		Node* temp = new Node();
		temp->data = *data;
		temp->left = NULL;
		temp->right = NULL;
		if (this->now->left)
		{
			this->now->right = temp;
			ct_node++;
			int max_node = pow(2, deep) - 1;
			if (ct_node >= max_node)
			{
				deep++;
			}
		}
		else
		{
			this->now->left = temp;
			ct_node++;
			int max_node = pow(2, deep) - 1;
			if (ct_node >= max_node)
			{
				deep++;
			}
		}
	}
	//递归法实现三种遍历方法
	//前序遍历
	void Preorder_traversal(Node* now,int mydeep=1)
	{
		
		if (deep == 0||deep == 1)
		{
			this->now = head;
			return;
		}
		else if (!now)
		{
			return;
		}
		else
		{
			//找到节点深度为n-1并且只有0或者1个孩子
			if (!flag&&mydeep == deep - 1 && (((now->left == NULL) && (now->right == NULL)) || ((now->left) && (now->right == NULL))))
			{
				this->now = now;
				flag = 1;
			}
			Preorder_traversal(now->left, mydeep + 1);
			Preorder_traversal(now->right, mydeep + 1);
			
		}
	}
	//前序遍历并打印
	void Preorder_traversal_print(Node* now)
	{
		if (!now)
			return;
		else
		{
			printf("%d ", now->data.id);
			Preorder_traversal_print(now->left);
			Preorder_traversal_print(now->right);
		}
	}
	//中序遍历并打印
	void Inorder_traversal(Node* now)
	{
		if (!now)
			return;
		else
		{
			Inorder_traversal(now->left);
			printf("%d ", now->data.id);
			Inorder_traversal(now->right);
		}
	}
	//后序遍历并打印
	void Postorder_traversal(Node* now)
	{
		if (!now)
			return;
		else
		{
			Postorder_traversal(now->left);
			Postorder_traversal(now->right);
			printf("%d ", now->data.id);
		}
	}
	//非递归法实现三种遍历方法
	//前序遍历并打印
	void Preorder_traversal()
	{
		if (head)
		{
			Node* now = head;
			while (s.size())
				s.pop();
			while (now||!s.empty())
			{
				while (now)
				{
					printf("%d ", now->data.id);
					s.push(*now);
					now = now->left;
				}
				//now也就是下一次循环可以想象成从右节点开始的一棵子树
				now = s.top().right;
				s.pop();
			}
		}
		else
		{
			return;
		}
	}
	//中序遍历并打印
	void Inorder_traversal()
	{
		if (head)
		{

			Node* now = head;
			while (s.size())
				s.pop();
			while (now || !s.empty())
			{
				for (; now; now = now->left)
				{
					s.push(*now);
				}
				
				now = &s.top();
				printf("%d ", now->data.id);
				s.pop();
				now = now->right;
			}
		}
		else
		{
			return;
		}
	}
	//后序遍历并打印
	void Postorder_traversal()
	{
		if (head)
		{
			Node* now = head;
			while (!s.empty())
			{
				s.pop();
			}
			while (now || !s.empty())
			{
				for (; now; now = now->left)
				{
					s.push(*now);
				}
				while (s.top().isprint)
				{
					now = &s.top();
					printf("%d ", now->data.id);
					s.pop();
					if (s.empty())
						goto tql;//跳出整个循环，并且可以返回了
				}
				now = &s.top();
				s.pop();
				now->isprint = 1;
				s.push(*now);
				now = now->right;
			}
		tql:now=now;
		}
		else
		{
			return;
		}
	}

	//层序遍历并打印
	void level_traversal()
	{
		queue <Node> q;
		now = head;
		q.push(*head);
		if (head)
		{
			while (1)
			{
				Node temp = q.front();
				printf("%d ", temp.data.id);
				q.pop();
				if (temp.left)
				{
					q.push(*temp.left);
				}
				if (temp.right)
				{
					q.push(*temp.right);
				}
				if (q.empty())
				{
					break;
				}
			}
			
		}
		else
		{
			return;
		}
	}
	
//属性
	//数据域
	Data data;
	int deep = 0;//深度，默认是0
	int flag = 0;//标记，只能有一个now指针返回
	//指针域
	Node* head;//最开始的指针
	Node* now;//递归时要用的指针
	int ct_node = 0;//记录节点数
};
//二叉树结构创建完毕
int main()
{
	BinTree* bintree = new BinTree();
	Data data;
	for (int i = 1; i <= 14; i++)
	{
		data.id = i;
		bintree->Insert(&data);
	}
	bintree->Preorder_traversal_print(bintree->head);
	printf("\n");
	bintree->Inorder_traversal(bintree->head);
	printf("\n");
	bintree->Postorder_traversal(bintree->head);
	printf("\n");
	bintree->Preorder_traversal();
	printf("\n");
	bintree->Inorder_traversal();
	printf("\n");
	bintree->Postorder_traversal();
	printf("\n");
	bintree->level_traversal();
	printf("\n");
	system("pause");
}