二叉树初学

#include <iostream>
using namespace std;
typedef char elemtype;
struct bitree
{
	elemtype data;
	bitree *lchild, *rchild;
};
bitree* create(string tree)//同深度下就算没有母节点，也要用空指针来填充位置
{
	bitree *q[100];
	bitree *s;//二叉链表中的结点
	bitree *root;//二叉链表的根指针
	int front = 1, rear = 0;//定义队列的头、尾指针
	char ch[100];//结点的data阈值
	root = NULL;
	strcpy_s(ch, tree.c_str());
	int num = 0;
	while (ch[num] != '#')//输入值为#号，算法结束
	{
		s = NULL;
		if (ch[num] != ',')//输入数据不为逗号，表示不为虚结点，否则为虚结点
		{
			s = new bitree;///new返回一个动态内存的首地址，s是一个指针
			s->data = ch[num];//这个节点下要存储的数据
			s->lchild = NULL;
			s->rchild = NULL;
		}
		rear++;
		q[rear] = s;//新节点或虚结点进队
		if (rear == 1)//说明是根节点
			root = s;
		else
		{ ///在生成新的节点的时候，判断该节点属于上一个母节点的左叉还是右叉，q[front]指向改节点的母节点，
		///又因为是二叉树，每个节点仅有2个儿子，所以可以用除2求余的方式确定是左叉还是右叉，利用了二叉树的性质深度h=log2（n+1）
			if ((s != NULL) && (q[front] != NULL))//如果是一个虚结点，那么s=NULL；这样根节点就过不了这个if，因为q[0]=NULL
			{
				if (rear % 2 == 0)
					q[front]->lchild = s;//rear为偶数，s为双亲左孩子
				else
					q[front]->rchild = s;
			}
			if (rear % 2 == 1)//根节点可以过这个if
				front++;//front=1(根节点)
		}
		//cin >> ch;
		num++;
	}
	return root;
}
void preorder(bitree* root)
{
	bitree* p;
	p = root;
	if (p != NULL)
	{
		cout << p->data << " ";
		preorder(p->lchild);//这里是一个递归，if为NULL成立了，退出。递归就是函数调用自身
		preorder(p->rchild);
	}
}
void preorder1(bitree* root)
{
	bitree *p, *s[100];//s【100】是一个堆栈，用记录当前寻找的"路径"；p用来存储当前节点
	int top = 0;
	p = root;
	while ((p != NULL) || (top > 0))
	{
		while (p != NULL)//判断当前节点是否为空
		{
			cout << p->data << " ";//输出当前节点存储的信息
			s[++top] = p;//++top导致了s[0]=NULL，也是整体程序可以退出的保证；记录当前这个有效节点
			p=p->lchild;//优先搜寻左边，当前节点更新为左边的节点
		}
		p = s[top--];//退出上面一个while说明，一条“路径”到头了，返回上一层的节点，然后搜寻右边
		p = p->rchild;
	}

}
void inorder(bitree *root)///中端遍历,挖到左节点为NULL，输出当前节点，然后探索当前节点的右侧（递归式）
{
	bitree* p;
	p = root;
	if (p != NULL)
	{
		inorder(p->lchild);
		cout << p->data << " ";///优先输出最底层的左节点的数据
		inorder(p->rchild);///第二优先输出同深度下的右节点的数据
	}
}
void inorder1(bitree *root)//非递归式
{
	bitree *p, *s[100];
	p = root;
	int top = 0;
	while (p != NULL || top > 0)
	{
		while (p != NULL)
		{
			s[++top] = p;
			p=(p->lchild);
		}
		
		p = s[top--]; 
		cout << p->data << " ";
		p = p->rchild;
		
				
	}
}
void postorder(bitree* root)//输出最深层的左侧，同深度的右侧
{
	bitree* p;
	p = root;
	if (p != NULL)
	{
		postorder(p->lchild);
		postorder(p->rchild);
		cout << p->data << " ";
	}

}
void postorder1(bitree* root)
{
	bitree *p,*s1[100];
	int s2[100], top = 0, b;
	p = root;
	do{
		while (p != NULL)
		{
			s1[top] = p;//s1[0]=p,s1存放树中的节点
			s2[top++] = 0;//s2【0】=0，s2存放进栈标志，第一次进栈标志为0
			p = p->lchild;//沿着左侧一直寻找，直到找到最左侧的叶节点
		}
		if (top > 0)
			b = s2[--top];//可能还是0

		p = s1[top];
		if (b == 0)
		{
			s1[top] = p;
			s2[top++] = 1;///第二次进栈标志
			p = p->rchild;
		}
		else
		{
			cout << p->data << " ";
			p = NULL;
		}
	} while (top > 0);

}
int main()
{
	string tree;
	tree = "ABCGDE,,HF#";
	bitree* a;
	a = create(tree);
	cout << "preorder:";
	preorder(a);
	cout <<endl<< "preorder1：";
	preorder1(a);
	cout <<endl<<"inorder: ";
	inorder(a);
	cout <<endl<< "inorder1: ";
	inorder1(a);
	cout << endl << "postorder:";
	postorder(a);
	cout << endl << "postorder1:";
	postorder1(a);
	while (1);

}

定义：
完全二叉树：只有最下面的两层结点度能够小于2，并且最下面一层的结点都集中在该层最左边的若干位置的二叉树。

如果一棵具有n个结点的深度为k的二叉树，它的每一个结点都与深度为k的满二叉树中编号为1~n的结点一一对应，这棵二叉树称为完全二叉树。

满二叉树：除了叶结点外每一个结点都有左右子叶且叶子结点都处在最底层的二叉树.

遍历：

前根遍历，先根节点，在左节点，最后右节点。

中根遍历，先左节点，在根节点，最后右节点。

后根遍历，先左节点，在右节点，最后根节点。

------------------------------------------------------------------假设深度为n的树

前根遍历最容易理解，顺着根节点下来，左侧优先，按照路过节点的顺序输出。输出完第n层的左侧的节点之后，如果同一母节点下有右节点，那么输出这个右节点。

中根， 找第n层的左侧节点，没有就输出次一层的根节点，然后是该根节点的右节点（也是第n层的）

后根，找第n层的最左节点，然后是第n层同母节点下的最左的右节点，然后同爷爷节点下的第n层的，次最左的节点，。。。。最左最深优先。。