【笔记】大话数据结构-树

树的存储结构

双亲表示法、孩子表示法、孩子兄弟表示法（复杂树变成二叉树）

二叉树

特点

最多两颗子树；左右子树有序；即使只有一颗子树，也要区分左右子树。

特殊二叉树

1. 斜树：只有左/右子树。
2. 满二叉树：所有分支都有左右子树，且所有叶子在同一层。
3. 完全二叉树：按层序编号，编号为i（1≤i≤n）的结点与同样深度满二叉树中编号i的结点位置相同。

性质

1. 第i层至多$2^{i-1}$个结点。
2. 深度为k的二叉树至多$2^k-1$个结点。
3. 终端结点数（叶子结点数）为n₀，度为2的结点数n₂，则n₀=n₂+1 。
4. 具有n个结点的完全二叉树深度为[log₂n]+1。
5. 具有n个结点的完全二叉树结点层序编号，对任意结点i，有（1）i=1，为根；i>1，双亲是结点[i/2]。 （2）若2i>n，结点i无左孩子；否则左孩子是结点2i。 （3）若2i+1>n，结点i无右孩子；否则右孩子是结点2i+1。

存储结构

1. 顺序：层序编号，不存在的设置为Λ。
2. 二叉链表：

lchild	data	rchild

遍历

1. 前序遍历：先访问根节点，再前序遍历左子树，最后前序遍历右子树。
   

2. 中序遍历：从根节点开始（但是不是访问），中序遍历根节点左子树，然后访问根节点，最后中序遍历右子树。
   

3. 后序遍历：从左到右先叶子后结点的方式遍历左右子树，最后访问根节点。
   

4. 层序遍历：从左到右，从上到下。
   
   已知前序/后序+中序就可以唯一确定二叉树，但已知前序+后序不可以（3个结点时就可能四种情况）。

建立

每个结点的空指针引出虚结点，指定为"#"。（扩展二叉树）。

typedef char TElemType;
typedef struct BiTNode
{
    
    
	TElemType data;
	struct BiTNode *lchild,*rchild;
} BiTNode,*BiTree;
void CreateBiTree(BiTree *T)
{
    
    
	TElemType ch;
	scanf("%c",&ch);
	if (ch=='#')
	 *T=NULL;
	else
	{
    
    
		*T=(BiTree)malloc(sizeof(BiTNode));
		if(!*T)
		 exit(-1);
		(*T)->data=ch;
		CreateBiTree(&(*T)->lchild);
		CreateBiTree(&(*T)->rchild);
	}
} 

线索二叉树

指向前驱和后继的指针称为线索，加上线索的二叉树就叫线索二叉树。

lchild	ltag	data	rtag	rchild

ltag为0指向左孩子，为1指向前驱；
rtag为0指向右孩子，为1指向后继。

#include "string.h"
#include "stdio.h"    
#include "stdlib.h"   
#include "io.h"  
#include "math.h"  
#include "time.h"
 
#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0
 
#define MAXSIZE 100 /* 存储空间初始分配量 */
 
typedef int Status;	/* Status是函数的类型,其值是函数结果状态代码,如OK等 */
typedef char TElemType;
typedef enum {
    
    Link,Thread} PointerTag;	/* Link==0表示指向左右孩子指针, */
										/* Thread==1表示指向前驱或后继的线索 */
typedef  struct BiThrNode	/* 二叉线索存储结点结构 */
{
    
    
	TElemType data;	/* 结点数据 */
	struct BiThrNode *lchild, *rchild;	/* 左右孩子指针 */
	PointerTag LTag;
	PointerTag RTag;		/* 左右标志 */
} BiThrNode, *BiThrTree;
 
TElemType Nil='#'; /* 字符型以空格符为空 */
 
Status visit(TElemType e)
{
    
    
	printf("%c ",e);
	return OK;
}
 
/* 按前序输入二叉线索树中结点的值,构造二叉线索树T */
/* 0(整型)/空格(字符型)表示空结点 */
Status CreateBiThrTree(BiThrTree *T)
{
    
     
	TElemType h;
	scanf("%c",&h);
 
	if(h==Nil)
		*T=NULL;
	else
	{
    
    
		*T=(BiThrTree)malloc(sizeof(BiThrNode));
		if(!*T)
			exit(OVERFLOW);
		(*T)->data=h; /* 生成根结点(前序) */
		CreateBiThrTree(&(*T)->lchild); /* 递归构造左子树 */
		if((*T)->lchild) /* 有左孩子 */
			(*T)->LTag=Link;
		CreateBiThrTree(&(*T)->rchild); /* 递归构造右子树 */
		if((*T)->rchild) /* 有右孩子 */
			(*T)->RTag=Link;
	}
	return OK;
}
 
BiThrTree pre; /* 全局变量,始终指向刚刚访问过的结点 */
/* 中序遍历进行中序线索化 */
void InThreading(BiThrTree p)
{
    
     
	if(p)
	{
    
    
		InThreading(p->lchild); /* 递归左子树线索化 */
		if(!p->lchild) /* 没有左孩子 */
		{
    
    
			p->LTag=Thread; /* 前驱线索 */
			p->lchild=pre; /* 左孩子指针指向前驱 */
		}
		if(!pre->rchild) /* 前驱没有右孩子 */
		{
    
    
			pre->RTag=Thread; /* 后继线索 */
			pre->rchild=p; /* 前驱右孩子指针指向后继(当前结点p) */
		}
		pre=p; /* 保持pre指向p的前驱 */
		InThreading(p->rchild); /* 递归右子树线索化 */
	}
}
 
/* 中序遍历二叉树T,并将其中序线索化,Thrt指向头结点 */
Status InOrderThreading(BiThrTree *Thrt,BiThrTree T)
{
    
     
	*Thrt=(BiThrTree)malloc(sizeof(BiThrNode));
	if(!*Thrt)
		exit(OVERFLOW);
	(*Thrt)->LTag=Link; /* 建头结点 */
	(*Thrt)->RTag=Thread;
	(*Thrt)->rchild=(*Thrt); /* 右指针回指 */
	if(!T) /* 若二叉树空,则左指针回指 */
		(*Thrt)->lchild=*Thrt;
	else
	{
    
    
		(*Thrt)->lchild=T;
		pre=(*Thrt);
		InThreading(T); /* 中序遍历进行中序线索化 */
		pre->rchild=*Thrt;
		pre->RTag=Thread; /* 最后一个结点线索化 */
		(*Thrt)->rchild=pre;
	}
	return OK;
}
 
/* 中序遍历二叉线索树T(头结点)的非递归算法 */
Status InOrderTraverse_Thr(BiThrTree T)
{
    
     
	BiThrTree p;
	p=T->lchild; /* p指向根结点 */
	while(p!=T)
	{
    
     /* 空树或遍历结束时,p==T */
		while(p->LTag==Link)
			p=p->lchild;
		if(!visit(p->data)) /* 访问其左子树为空的结点 */
			return ERROR;
		while(p->RTag==Thread&&p->rchild!=T)
		{
    
    
			p=p->rchild;
			visit(p->data); /* 访问后继结点 */
		}
		p=p->rchild;
	}
	return OK;
}
 
int main()
{
    
    
	BiThrTree H,T;
	printf("请按前序输入二叉树(如:'ABDH##I##EJ###CF##G##')\n");
 	CreateBiThrTree(&T); /* 按前序产生二叉树 */
	InOrderThreading(&H,T); /* 中序遍历,并中序线索化二叉树 */
	printf("中序遍历(输出)二叉线索树:\n");
	InOrderTraverse_Thr(H); /* 中序遍历(输出)二叉线索树 */
	printf("\n");
	
	return 0;
}
 
 

赫夫曼树

树中一个结点到另一个结点分支构成两个结点间路径，路径上的分支数目就是路径长度。树的路径长度就是根节点到每一结点路径长度之和。
考虑带权，带权路径长度WPL最小的二叉树称作赫夫曼树（最优二叉树）。