1. 树的概念：

    1. 树：由n个结点组成的有限集，有且只有一个根结点（由根结点可以访问后继结点），其他结点只有一个前驱结点，但可以有多个后继结点（一对多）。当n = 0时，为空树。

    2. 叶子结点（终端结点）：只有前驱结点没有后继结点；非叶子结点，即为分支结点。

    3. 度：子结点的个数称之为度。

    4. 树的度：树中各节点度的最大值。（默认为广度）

    5. 深度：从根结点到最底层结点的层数。

    6. 森林：n个互不相交的树的集合。

2. 二叉树的概念：

    1. 二叉树：

        任意一个结点的子结点个数不能超过2个（树的度为2），且子节点的位置不可更改（一旦改变位置，就是两个不一样的二叉树）。

    2.  满二叉树：

        在不增加树的层数的前提下，无法再增加一个结点的二叉树。（叶子结点处在同一层，除了叶子结点以外，其余所有的结点的度都为2）

        特性：满二叉树第k层有2^(k-1)个结点，k层满二叉树总共有2^k-1个结点。

        练习：总结点为4847，求叶子结点为多少？

            首先：2^12 - 1 = 4096 - 1 = 4095， 即可以推断出有13层，即4847 - 4095 = 752个

            但第12层有：2^11 = 2048个，非叶子结点有752 / 2 = 376个

            所以叶子结点：2048 - 376 + 752 = 2424个

    3. 完全二叉树：

        只是删除了满二叉树最底层最右边的连续若干个结点，形成了完全二叉树。

        注意：1. 满二叉树是完全二叉树，但完全二叉树不一定是满二叉树。

                   2. 在满二叉树的基础上，如果要增加结点只能从上至下，从左至右的增加结点；如果要减少结点，只能从下至上，从右至左的删除结点。

3. 二叉树的遍历：

    主要研究一对多的树形结构存储到一对一的线性存储单元中：

    1. 前序遍历：先遍历根节点，再遍历左子树，最后遍历右子树（上图ABCEDFG）

    2. 中序遍历：先遍历左子树，再遍历根节点，最后遍历右子树（上图CBEAFDG）

    3. 后序遍历：先遍历左子树，在遍历右子树，最后遍历根节点（上图CEBFGDA）

    4. 层序遍历：从上至下，从左至右，依次遍历（上图ABDCEFG）

        注意：上诉前三种遍历方法为深度优化算法，第四种遍历方法为广度优先算法。

    练习：

        1. 如果只知道一个二叉树的前序遍历为ABC，求二叉树可能的情况：

        2. 如果知道一个二叉树的前序遍历为ABC，后序遍历为CBA，求二叉树可能的情况：

       3. 知道一个二叉树的前序遍历ABCEHDFG，中序遍历CBHEAFDG，求二叉树可能的情况：

        4. 知道一个二叉树的中序遍历CBHEAFDG，后续遍历CHEBFGDA，求二叉树可能的情况：

        从以上练习我们可以知道二叉树的遍历特性：如果只知道一个二叉树的前序遍历不能还原唯一的二叉树，知道前序遍历+后序遍历也不行，必须知道前序遍历+中序遍历，或者后序遍历+中序遍历才能得到唯一确定的一颗二叉树。

4. 二叉树的实现：

    1. 二叉树的定义：

typedef char BTDATA_TYPE;

typedef struct tree_node
{
	BTDATA_TYPE data;
	struct tree_node *pl;
	struct tree_node *pr;
}TREE_NODE;

    2. 二叉树的创建：

int idx = 0;
int cnt = 0;
char tree[] = {"ABC##EH###DF##G##"};

TREE_NODE *Create_BTree(void)
{
	BTDATA_TYPE data = tree[idx++];
	if(data == '#')
	{
		return NULL;
	}

	TREE_NODE *pnode = malloc(sizeof(TREE_NODE));
	if(pnode == NULL)
	{
		perror("fail to malloc");
		return NULL;
	}
	
	pnode->data = data;
	pnode->pl = Create_BTree();
	pnode->pr = Create_BTree();

	return pnode;
}

    3. 二叉树的前序遍历：

void Pre_Order(TREE_NODE *proot)
{
	if(proot == NULL)
	{
		return;
	}
	printf("%c", proot->data);
	Pre_Order(proot->pl);
	Pre_Order(proot->pr);
}

    4. 二叉树的中序遍历：

void Mid_Order(TREE_NODE *proot)
{
	if(proot == NULL)
	{
		return;
	}
	Mid_Order(proot->pl);
	printf("%c", proot->data);
	Mid_Order(proot->pr);
}

    5. 二叉树的后序遍历：

void Pos_Order(TREE_NODE *proot)
{
	if(proot == NULL)
	{
		return;
	}
	Pos_Order(proot->pl);
	Pos_Order(proot->pr);
	printf("%c", proot->data);
}

    6. 二叉树的层序遍历（结合前一篇的队列实现）：

void Link_Layer_Order(TREE_NODE *proot)
{
	QUEUE_LIST *pque = Create_Queue_List();
	if(pque == NULL)
	{
		printf("fail to create queue list\n");
		return;
	}
	
	QUEUE_NODE *pnode = Create_Queue_Node(proot);
	if(pnode == NULL)
	{
		printf("fail to create queue node\n");
		return;
	}

	DATA_TYPE outdata;
	Push_Queue_Link(pque, pnode);

	while(!Is_Empty_Queue(pque))
	{
		Pop_Queue_Link(pque, &outdata);
		printf("%c", outdata->data);
		

		if(outdata->pl != NULL)
		{
			pnode = Create_Queue_Node(outdata->pl);
			Push_Queue_Link(pque, pnode);
		}

		if(outdata->pr != NULL)
		{
			pnode = Create_Queue_Node(outdata->pr);
			Push_Queue_Link(pque, pnode);
		}
		
	}

	Destory_Queue(pque);

	return;
}

    7. 获得二叉树的结点个数：

int Get_PTree_Node_Cnt(TREE_NODE *proot)
{
	if(proot == NULL)
	{
		return 0;
	}
	return 1+Get_PTree_Node_Cnt(proot->pl) + Get_PTree_Node_Cnt(proot->pr);
}

    8. 获得二叉树的层数：

int Get_PTree_Layer_Cnt(TREE_NODE *proot)
{
	if(proot == NULL)
	{
		return 0;
	}
	int layl = Get_PTree_Layer_Cnt(proot->pl);
	int layr = Get_PTree_Layer_Cnt(proot->pr);

	return layl > layr ? layl+1 : layr+1;
}

    9. 销毁二叉树：

void Destroy_PTree(TREE_NODE *proot)
{
	if(proot == NULL)
	{
		return;
	}
	Destroy_PTree(proot->pl);
	Destroy_PTree(proot->pr);
	free(proot);
}