数据结构学习笔记Day5（连载中）

树

（1）树的定义

专业定义：

        ①有且只有一个称为根的节点

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

通俗定义：

        ①树是由节点和边组成

        ②每个节点只有一个父节点，但可以有多个子节点

        ③但有一个例外，该节点没有父节点，此节点称为根节点

（2）树的专业术语

节点    父节点    子节点    子孙    兄弟    堂兄弟    祖先

深度：

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

叶子节点：没有子节点的节点

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

度：

      子节点的个数称为度
      树的度是含有最大子节点的度

（3）树的分类

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

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

二叉树的分类：

      一般二叉树；

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

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

      完全二叉树包含满二叉树，满二叉树是一个特殊的完全二叉树

③森林：n个互不相交的树的集合

（4）树的存储

①二叉树的存储

连续存储【完全二叉树】

      优点：查找某个节点的父节点和子节点（也包括判断有没有子节点）速度很快

      缺点：耗用内存空间过大

链式存储

②一般树的存储

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

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

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

二叉树表示法：把一个普通树转化成二叉树来存储

      具体转换方法：设法保证任意一个节点的左指针域指向它的第一个孩子节点，右指针域指向它的下一个兄弟节点，只要能满足此条件，就可以把一个普通树转化为二叉树。

③森林的存储

      先把森林转化为二叉树，在存储二叉树

（5）树的操作

①遍历

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

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

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

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

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

换句话说：只用通过先序和中序，或通过中序和后序，我们才可以确定一个二叉树

示例1：

先序：ABCDEFGH

中序：BDCEAFHG

求后序：DECBHGFA

示例2：

先序：ABDGHCEFI

中序：GDHBAECIF

求后序：GHDBEIFCA

示例3：

中序：BDCEAFHG

后序：DECBHGFA

求先序：ABCDEFGH

（6）树的应用

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

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

     &nbsp**;面向对象语言中类的继承关系**本身就是一棵树

      哈夫曼树

（7）链式二叉树程序

 #include <stdio.h>
    #include <malloc.h>
    
    struct BTNode
    {
    	char data;
    	struct BTNode * pLchild;	//p是指针，L是左，child是孩子 
    	struct BTNode * pRchild;
    };
    
    struct BTNode * CreateBTree(void);
    void PreTraverseBTree(struct BTNode *);
    void InTraverseBTree(struct BTNode *);
    void PostTraverseBTree(struct BTNode *);
    
    int main(void)
    {
    	struct BTNode * pT = CreateBTree();
    	
    	//PreTraverseBTree(pT);	//先序遍历 
    	//InTraverseBTree(pT);	//中序遍历 
    	PostTraverseBTree(pT);	//后序遍历 
    	
    	return 0;
    }
    
    void PreTraverseBTree(struct BTNode * pT)
    {
    	/*
    		伪算法 
    		先访问根节点
    		再先序访问左子树
    		再先序访问右子树 
    	*/
    	if (NULL != pT)
    	{
    		printf("%c\n", pT->data);
    		//pT->pLchild代表整个左子树
    		//pT->pRchild代表整个右子树
    		if (NULL != pT->pLchild)
    		{
    			PreTraverseBTree(pT->pLchild);
    		}
    		if (NULL != pT->pRchild)
    		{
    			PreTraverseBTree(pT->pRchild);
    		}
    	}
    } 
    
    void InTraverseBTree(struct BTNode * pT)
    {
    	if (NULL != pT)
    	{
    		if (NULL != pT->pLchild)
    		{
    			InTraverseBTree(pT->pLchild);
    		}
    		
    		printf("%c\n", pT->data);
    		
    		if (NULL != pT->pRchild)
    		{
    			InTraverseBTree(pT->pRchild);
    		}
    	}
    }
    
    void PostTraverseBTree(struct BTNode * pT)
    {
    	if (NULL != pT)
    	{
    		if (NULL != pT->pLchild)
    		{
    			PostTraverseBTree(pT->pLchild);
    		}
    		if (NULL != pT->pRchild)
    		{
    			PostTraverseBTree(pT->pRchild);
    		}
    		
    		printf("%c\n", pT->data);
    	}
    }
    
    struct BTNode * CreateBTree(void)
    {
    	struct BTNode * pA = (struct BTNode *)malloc(sizeof(struct BTNode));
    	struct BTNode * pB = (struct BTNode *)malloc(sizeof(struct BTNode));
    	struct BTNode * pC = (struct BTNode *)malloc(sizeof(struct BTNode));
    	struct BTNode * pD = (struct BTNode *)malloc(sizeof(struct BTNode));
    	struct BTNode * pE = (struct BTNode *)malloc(sizeof(struct BTNode));
    	
    	pA->data = 'A';
    	pB->data = 'B';
    	pC->data = 'C';
    	pD->data = 'D';
    	pE->data = 'E';
    	
    	pA->pLchild = pB;
    	pA->pRchild = pC;
    	pB->pLchild = pB->pRchild = NULL;
    	pC->pLchild = pD;
    	pC->pRchild = NULL;
    	pD->pLchild = NULL;
    	pD->pRchild = pE;
    	pE->pLchild = pE->pRchild = NULL;
    	
    	return pA;	
    }