数据结构学习笔记之二叉树

定义：

        专业定义：

            1、有且只有一个称为根的节点

            2、有若干个互不相交的子树，这些子树本身也是一棵树

        通俗定义：

            1、树是由节点和边组成

            2、 每个节点只有一个父节点但可以有多个子节点

            3、但有一个节点例外，该节点没有父节点，此节点称为父节点

            专业的术语：

                    节点、父节点、子节点、子孙、堂兄弟

                    深度：从根节点到最底层节点的层数称之为深度，根节点是第一层

                    非终端节点：实际就是非叶子节点

                    度：子节点的个数，树的度为子节点最大的个数

分类：

            一般树：任意一个节点的子节点个数不受限制

            二叉树：任意一个节点的子节点个数最多两个，且子节点的位置不可更改

                        分类：

                                一般二叉树

                                满二叉树：在不增加树的层数的前提下，无法再多添加一个节点的二叉树就是满二叉树

                                完全二叉树：如果只是删除了满二叉树最底层最右边的连续若干个节点，这样形成的二叉树就是完全二叉树 

 

            森林：

                    n个互不相交的树的集合

树的存储：

            二叉树的存储

                        连续存储【完全二叉树】

                                    优点：    

                                            查找某个节点的父节点和子节点（也包括判断有没有左右节点）

                                    缺点：

                                               耗用内存空间过大

                        链式存储

                  一般树的存储

                                双亲表示法：求父节点方便

                                孩子表示法：求子节点方便

                                孩子双亲表示法：求父节点和子节点都很方便

                                二叉树表示法：把一个普通树转化成二叉树来存储，具体转换方法：

                                                       设法保证任一一个节点的左指针域指向它的第一个孩子

                                                                                                右指针域指向它的堂兄弟

                                                        只要能满足条件就能把普通树转化为二叉树

                                                        一个普通树转化成的二叉树一定没有右子树，指向他的堂兄弟

                

                   森林的存储：根节点当做堂兄弟 ->二叉树表示法

操作：

            遍历：先序遍历：先访问根节点，再先序访问左子树，再后序访问右子树

                        中序遍历：中序遍历左子树，再访问根节点，再中序遍历右子树

                        后序遍历：先中序遍历左子树，再中序遍历右子树，再访问根节点

            已知两种遍历序列求原始二叉树

                        已知先序和中序或者已知中序和后序，我们可以还原出原始二叉树，但是通过先序和后序是无法还原吃原始的二叉树的

                        换种说法:只有通过先序和中序，或者通过中序和后序我们才可以唯一缺点一个二叉树

已知先序和中序求->原始二叉树->后序：

            例：先序ABCDEFGH, 中序BDCEAFHG ---->后序：DECBHHGFA

                       由先序 A一定是根节点， 由中序BDCE 在A的左边，FHG在A的右边

                        再看A中谁先出现 谁就是根 在看B中 再分左右

已知中序和后序求->原始二叉树->先序：

             例：中序BDCEAFHG，后序DECBHGFA

                        后序的最后一个为根节点，再中序分左右

                        由后序可知A一定是根节点   BDCE 在A左边，FHG在A右边

                            再由后序倒过来看  B就是根节点， 由中序知DCE在B右边

                            再由后序知C是B的右子树  再由中序知D在C左边  E在C右边~

                        右边同理

                        

                        

树的应用

                树是数据库中数据组织一种重要形式

                操作系统子父进程的关系本身就是一棵树

                面向对象语言中类的继承关系

                霍夫曼树

                

树的二叉树遍历具体程序演示：

#include <stdio.h>
#include <malloc.h>
#include <stdlib.h>

typedef struct BinaryTree
{
	int  data;
	struct BinaryTree * pLchild; 
	struct BinaryTree * pRchild;
}BTREE;

BTREE * creatBTree(void);
void PreTraverseBTree(BTREE *);
void InTraverseBTree(BTREE *);
void PostTraverseBTree(BTREE *);

int main()
{
	BTREE * pT = creatBTree();

//	PreTraverseBTree(pT);
	InTraverseBTree(pT);
//	PostTraverseBTree(pT);
	
	system("pause");
	return 0;
}

BTREE * creatBTree(void)
{
	BTREE * pA = (BTREE *)malloc(sizeof(BTREE));
	BTREE * pB = (BTREE *)malloc(sizeof(BTREE));
	BTREE * pC = (BTREE *)malloc(sizeof(BTREE));
	BTREE * pD = (BTREE *)malloc(sizeof(BTREE));
	BTREE * pE = (BTREE *)malloc(sizeof(BTREE));

	pA->pLchild = pB;
	pA->pRchild = pC;
	pA->data = 'A';
	pB->pLchild = NULL;
	pB->pRchild = NULL;
	pB->data = 'B';
	pC->pLchild = pD;
	pC->pRchild = NULL;
	pC->data = 'C';
	pD->pLchild = NULL;
	pD->pRchild = pE;
	pD->data = 'D';
	pE->pLchild = NULL;
	pE->pRchild = NULL;
	pE->data = 'E';

	return pA;
}

void PreTraverseBTree(BTREE * pT)
{
	//根、左、右
	if (NULL != pT)
	{

		printf_s("%c\n", pT->data);
		if (NULL != pT->pLchild)
		{
			PreTraverseBTree(pT->pLchild);
		}
		if (NULL != pT->pRchild)
		{
			PreTraverseBTree(pT->pRchild);
		}
	}
}

void InTraverseBTree(BTREE * pT)
{
	if (NULL != pT)
	{
		if (NULL != pT->pLchild)
		{
			InTraverseBTree(pT->pLchild);
		}
		printf_s("%c\n", pT->data);
		if (NULL != pT->pRchild)
		{
			InTraverseBTree(pT->pRchild);
		}
	}
}

void PostTraverseBTree(BTREE * pT)
{
	if (NULL != pT)
	{
		if (NULL != pT->pLchild)
		{
			PostTraverseBTree(pT->pLchild);
		}
		if (NULL != pT->pRchild)
		{
			PostTraverseBTree(pT->pRchild);
		}
		printf_s("%c\n", pT->data);
	}
}