二叉树性质 && 四种遍历方式

二叉树基本概念：

• 每个结点最多有两棵子树，左子树和右子树（有左右之分）

性质：

• 二叉树的第n层上最多有2^(n-1)个元素
• 高度为h的二叉树最多有2^h-1个结点
• 设一棵二叉树的叶子节点数为a，度为2的节点树为b，那么有a = b+1

满二叉树：

• 对于高度为h的满二叉树，节点树刚好为最大值2^h-1

完全二叉树：

• 对于高度为h的完全二叉树，若把第h层的节点全部删除，那么剩下的就是一棵高度为h-1的满二叉树
• 第h层的叶子必须从左往右靠齐

二叉树的遍历：

• 遍历二叉树的所有结点且每个节点仅访问一次，有4种不同的遍历方式：前序遍历，中序遍历，后序遍历，层次遍历
• 层次遍历：从根开始广搜即是层次遍历
• (preorder)前序遍历：根节点->左子树->右子树（根节点在前面）
• (inorder)中序遍历：左子树->根节点->右子树（根节点在中间，最常用的遍历方式）
• (postorder)后序遍历：左子树->右子树->根节点（根节点在后边）

1. 前序遍历：ABDGHCEIF
2. 中序遍历：GDHBAEICF
3. 后序遍历：GHDBIEFCA

#include<stdio.h>
#include<stack>
#include<vector>
using namespace std;
typedef struct Node
{
	char val;
	Node *l, *r;
	Node(int x): val(x), l(nullptr), r(nullptr)  {}
}Tree;
int L[9][9] = {{0,1},{0,0,0,1},{0,0,0,0,1},{0,0,0,0,0,0,1}};
int R[9][9] = {{0,0,1},{},{0,0,0,0,0,1},{0,0,0,0,0,0,0,1},{0,0,0,0,0,0,0,0,1}};
void Create(Tree *root)
{
	int i;
	for(i=0;i<=8;i++)
	{
		if(L[(*root).val-'A'][i])
		{
			Tree *p = new Tree(i+'A');
			(*root).l = p;
			Create(p);
		}
		if(R[(*root).val-'A'][i])
		{
			Tree *q = new Tree(i+'A');
			(*root).r = q;
			Create(q);
		}
	}
}
void Preorder1(Tree *p)
{
	if(p==nullptr)
		return;
	printf("%c", (*p).val);
	Preorder1((*p).l);
	Preorder1((*p).r);
}
void Inorder1(Tree *p)
{
	if(p==nullptr)
		return;
	Inorder1((*p).l);
	printf("%c", (*p).val);
	Inorder1((*p).r);
}
void Postorder1(Tree *p)
{
	if(p==nullptr)
		return;
	Postorder1((*p).l);
	Postorder1((*p).r);
	printf("%c", (*p).val);
}
void Preorder2(Tree *p)
{
	stack<Tree*> st;
	if(p==nullptr)
		return;
	st.push(p);
	while(st.empty()==0)
	{
		p = st.top();
		st.pop();
		printf("%c", (*p).val);
		if((*p).r!=nullptr)
			st.push((*p).r);
		if((*p).l!=nullptr)
			st.push((*p).l);
	}
}
void Inorder2(Tree *p)
{
	stack<Tree*> st;
	if(p==nullptr)
		return;
	while(p || st.empty()==0)
	{
		if(p)
		{
			st.push(p);
			p = (*p).l;
		}
		else
		{
			p = st.top();
			st.pop();
			printf("%c", (*p).val);
			p = (*p).r;
		}
	}
}
void Postorder2(Tree *p)
{
	stack<Tree*> st;
	vector<Tree*> G;
	if(p==nullptr)
		return;
	st.push(p);
	while(st.empty()==0)
	{
		p = st.top();
		st.pop();
		G.insert(G.begin(), p);
		if((*p).l!=nullptr)
			st.push((*p).l);
		if((*p).r!=nullptr)
			st.push((*p).r);
	}
	for(auto i: G)
		printf("%c", (*i).val);
}
int main(void)
{
	Tree *root = new Tree('A');
	Create(root);
	Preorder1(root);  puts("");
	Inorder1(root);  puts("");
	Postorder1(root);  puts("");
	puts("-----------------------------");
	Preorder2(root);  puts("");
	Inorder2(root);  puts("");
	Postorder2(root);  puts("");
	return 0;
}