17.数据结构 树和二叉树

一.树

树的定义：
树是n(n>=0)个结点的有限集。
n=0，称为空树
树的基本术语：

**有序树：**树中结点的各子树从左到右有次序（最左边的为第一个孩子）
**无须树：**树中结点的各子树无次序
**森林：**是m（m≥0）棵互不相交的树的集合；把根结点删除树就变成了森林，一棵树可以看成是一个特殊的森林，给森林中的各子树加上一个双亲结点，森林就变成了树。
树一定是森林，森林不一定是树。
树结构和线性结构的比较：

二.二叉树

二叉树的定义
所有的树都能转为唯一对应的二叉树，不失一般性
特点：
1.每个结点最多有两个孩子（二叉树中不存在度大于2的结点）。
2.子树有左右之分，其次序不能颠倒。
3.二叉树可以是空集合，根可以有空的左子树或空的右子树。
**注！**二叉树不是树的特殊情况，他们是两个概念。
二叉树的子树要区分左子树和右子树，即使只有一棵子树也要进行区分，说明他是左子树，还是右子树。
树当结点只有一个孩子时，就无需区分他是左还是右的次序。因此二者是不同的。这是二叉树与树的最主要的差别。
二叉树中每个结点位置或者说次序都是固定的，可以是空，但是不可以说他位置，而树的结点位置是相对于别的结点来说的，没有别的结点时，他就无所谓左右了。

注：虽然二叉树和树概念不同，但有关树的基本术语对二叉树都适用。

三.树和二叉树的抽象数据类型定义

二叉树的抽象数据类型定义

四.二叉树的性质和存储结构

二叉树的性质：

两种特殊形式的二叉树：
满二叉树：


完全二叉树：

二叉树的存储结构：

二叉树的顺序存储

//二叉树的顺序存储表示
#define MAXSIZE 100
typedef TElemType SqBiTree[MAXSIZE]
SqBiTree bt;

n个结点的二叉链表中，有n-1个空指针域

//二叉链表存储结构
typedef struct BiNode
{
	TelemType data;
	struct TriTNode *lchild, *rchild;
}BiNode, *BiTree;
//三叉链表存储结构
typedef struct TriTNode
{
	TelemType data;
	struct TriTNode *lchild, *parent, *rchild;
}TriTNode,*TriTree;

先序遍历–前缀表达式
中序遍历–中缀表达式
后序遍历–后缀表达式
二叉树中各结点值不同 确定唯一 先序、中序、后序
先序+中序/中序+后序 确定唯一 二叉树

五.二叉树的遍历

//二叉树的先序遍历
void Pre(BiNode *p)
{
	if (p == NULL)
		return OK;//空二叉树
	else
	{
		Visit(p);//访问根节点
		preorder(p->lchild);//递归遍历左子树
		preorder(p->rchild);//递归遍历右子树
	}
}

void Pre(BiTree *T)
{
	if (T != NULL)
	{
		printf("%d\t", T->data);
		pre(T->lchild);
		pre(T->rchild);
	}
}

遍历二叉树的非递归算法
中序遍历可以用栈实现
基本思想：
1.建立一个栈
2.根结点进栈，遍历左子树
3.根节点出栈，输出根节点，遍历右子树

Status InOrderTraverse(BiTree T)
{
	BiTree p;
	InitStack(S);
	p = T;
	while (p || !StackEmpty(S))
	{
		if (p)
		{
			Push(S, p);
			p = p->lchild;
		}
		else
		{
			Pop(S, q);
			printf("%c", q->data);
			p = q->rchild;
		}
	}
	return OK;
}

二叉树的层次遍历
使用队列
1.将根节点入队
2.队不空时循环：从队列中出队一个结点*p，访问他；
若有左孩子结点，将左孩子结点入队；
若有右孩子结点，将右孩子结点入队。

//使用队列类型定义
typedef struct
{
	BTNode data[MaxSize];//存放队中元素
	int front, rear;//队头、队尾指针
}SqQueue;//顺序循环队列类型

//二叉树层次遍历
void LevelOrder(BTNode *b)
{
	BTNode *p;
	SqQueue *qu;
	InitQueue(qu);//初始化队列
	EnQueue(qu, b);//根结点指针入队
	while (!QueueEmpty(qu))//队不空，则循环
	{
		DeQueue(qu, p);//出队结点p
		printf("%c", p->data);//访问p结点
		if (!p->lchild)//有左孩子时将其进队
			EnQueue(qu, p->lchild);
		if (!p->rchild)//有右孩子时将其进队
			EnQueue(qu, p->rchild);
	}
}

六.二叉树遍历算法的应用

1.二叉树的建立
按先序遍历序列建立二叉树的二叉链表
例：已知先序序列为：
ABCDEGF
（1）从键盘输入二叉树的结点信息，建立二叉树的存储结构
（2）在建立二叉树的过程中按照二叉树先序方式建立

按照下图所示二叉树，按下列顺序读入字符：
ABC##DE#G##F###

Status CreateBiTree(BiTree &T)
{
	scanf(&ch);//cin>>ch;
	if (ch == "#")
		T = NULL;
	else
	{
		T = (BiNode*)malloc(sizeof(BiNode));//T=new BiTNode；
		if (!T)
			return(OVERFLOW);
		T->data = ch;//生成根结点
		CreateBiTree(T->lchild);//构造左子树
		CreateBiTree(T->rchild);//构造右子树
	}
	return OK;
}

2.复制二叉树
如果是空树，递归结束
否则，申请新结点空间，复制根结点
递归复制左子树
递归复制右子树

int Copy(BiTree T, BiTree &NewT)
{
	if (T == NULL)
	{
		NewT = NULL;
		return 0;
	}
	else
	{
		NewT = new BiNode;
		NewT->data = T->data;
		Copy(T->lchild, NewT->lchild);
		Copy(T->rchild, NewT->rchild);
	}
}

计算二叉树的深度
如果是空树，则深度为0；
否则，递归计算左子树的深度记为m，递归计算右子树的深度记为你，二叉树的深度为m与n的较大者+1

int Depth(BiTree T)
{
	if (T == NULL)
	{
		return 0;
	}
	else
	{
		m = Depth(T->lchild);
		n = Depth(T->rchild);
		if (m > n)
			return (m + 1);
		else
			return (n + 1);
	}
}

计算二叉树结点总数
如果是空树，则结点个数为0；
否则，结点个数 = 左子树的结点个数 + 右子树的结点个数 + 1。

int NodeCount(BiTree T)
{
	if (T == NULL)
	{
		printf("无结点\n");
		return 0;
	}
	else
	{
		m = NodeCount(T->lchild);
		n = NodeCount(T->rchild);
		return(m + n + 1);
	}
}

计算叶子结点的个数
如果是空树，则叶子结点的个数为0；
否则，为左子树的叶子结点个数+右子树的叶子结点个数。

int LeadCount(BiTree T)
{
	if (T == NULL)
	{
		return 0;//如果是空树返回0
	}
	else
	{
		if (T->lchild == NULL && T->rchild == NULL)
		{
			return 1;//如果是叶子结点返回1
		}
		else
		{
			m = LeadCount(T->lchild);
			n = LeadCount(T->rchild);
			return (m + n);
		}
	}
}

七.线索二叉树

寻找特定遍历序列中二叉树结点的前驱和后继
利用二叉链表中的空指针域：
如果某个结点的左孩子为空，则将空的左孩子指针域改为指向其前驱；
如果某个结点的右孩子为空，则将空的右孩子指针域改为指向其后继。
----这种改变指向的指针称为“线索”
对二叉树按某种遍历次序使其变为线索二叉树的过程叫线索化。

增加一个头结点：
ltag=0，lchild指向根结点，
rtag=1，rchild指向遍历序列中最后一个结点
遍历序列中第一个结点的lc域和最后一个结点的rc域都指向头结点

八.树和森林

树的存储结构
1.双亲表示法
实现：定义结构数组，存放树的结点，每个结点含两个域：
数据域：存放结点本身信息
双亲域：指示本结点的双亲结点在数组中的位置

//结点结构
typedef struct PTNode
{
	TElemType data;
	int parent;//双亲位置域
}PTNode;
//树结构
#define MAX_TREE_SIZE 100
typedef struct
{
	PTNode nodes[MAX_TREE_SIZE];
	int r, n;//根结点的位置和结点个数
}PTree;

2.孩子链表

//孩子结点结构
typedef struct CTNode
{
	int child;
	struct CTNode *next;
}ChildPtr;
//双亲结点结构
typedef struct
{
	TElemType data;
	ChildPtr firstchild;//孩子链表头指针
}CTBox;
//树结构
typedef struct
{
	CTBox nodes[MAX_TREE_SIZE];
	int n, r;//结点数和根结点的位置
};

3.带双亲的孩子链表

4.孩子兄弟表示法（二叉树表示法、二叉链表表示法）

typedef struct CSNode
{
	ElemType data;
	struct CSNode *firstchild, *nextsibling;
}CSNode,*CSTree;

左孩子、右兄弟

树转换成二叉树
给定一棵树，可以找到唯一的一棵二叉树与之对应
1.加线：在兄弟之间加上连线
2.抹线：对每个结点，除了其左孩子外，去除其与其余孩子之间的关系
3.旋转：以树的根结点为轴心，将整树顺时针转45°

树变二叉树：兄弟相连留长子

二叉树转换成树
1.加线：若p结点是双亲结点的左孩子，则将p的右孩子、右孩子的右孩子…沿分支找到的所有右孩子，都与p的双亲用线连起来
2.抹线：抹掉原二叉树中双亲与右孩子之间的连线
3.调整：将结点按层次排列，形成树结构

二叉树变树：
左孩右右连双亲，去掉原来右孩线。

森林转换成二叉树（二叉树与多棵树之间的关系）
1.将各棵树分别转换成二叉树
2.将每棵树的根结点用线相连
3.以第一棵树根结点为二叉树的根，再以根结点为轴心，顺时针旋转，构成二叉树型结构
树变二叉根相连

二叉树转换成森林
1.抹线：将二叉树中根结点与其右孩子连线，及沿右分支搜索到的所有右孩子间连线全部抹掉，使之变程孤立的二叉树
2.还原：将孤立的二叉树还原成树
去掉全部右孩线，孤立二叉再还原

九.树和森林的遍历

1.树的遍历（三种方式）

先根遍历：
若树不空，则先访问根结点，然后依次先根遍历各棵子树。
遍历结果：ABCDE
后根遍历：
若树不空，则先依次后根遍历各棵子树，然后访问根结点。
遍历结果：BDCEA
层次遍历：
若树不空，则自上而下自左而右访问树中每个结点。
遍历结果：ABCED
2.森林的遍历
将森林看作由三部分构成：
1.森林中第一棵树的根结点
2.森林中第一棵树的子树森林
3.森林中其他树构成的森林

1.先序遍历：
若森林不空，则
1.访问森林中第一棵树的根结点；
2.先序遍历森林中第一棵树的子树森林；
3.先序遍历森林中（除第一棵树之外）其余树构成的森林。
2.中序遍历：
若森林不空，则
1.中序遍历森林中第一棵树的子树森林；
2.访问森林中第一棵树的根结点；
3.中序遍历森林中（除第一棵树之外）其余树构成的森林。
即：依次从左至右对森林中的每一棵树进行后根遍历。

十.哈夫曼树及其应用

哈夫曼树的基本概念：
哈夫曼树（最优二叉树）
路径：从树中一个结点到另一个结点之间的分支构成这两个结点间的路径。
结点的路径长度：两个结点间路径上的分支数。
树的路径长度：从树根到每个结点的路径长度之和。记作：TL
结点数目相同的二叉树中，完全二叉树是路径长度最短的二叉树。
但最短的二叉树不一定是完全二叉树。
权：将树中结点赋给一个有着某种含义的数值，则这个数值称为该结点的权。
结点的带权路径长度：从根结点到该结点之间的路径长度与该结点的权的乘积。
树的带权路径长度：树中所有叶子结点的带权路径长度之和。记作：WPL

哈夫曼树：最优树 带权路径长度（WPL）最短的树
注：“带权路径长度最短”是在“度相同”的树中比较而得的结果，因此有最优二叉树/最优三叉树之称等等。
哈夫曼树：最优二叉树 带权路径长度（WPL）最短的二叉树
满二叉树不一定是哈夫曼树
哈夫曼树中权越大的叶子离根越近
带有相同带权结点的哈夫曼树不唯一
哈夫曼树的构造算法
贪心算法：构造哈夫曼树时首先选择权值小的叶子结点

包含n个叶子结点的哈夫曼树中共有2n-1个结点
哈夫曼树的结点度数为0或2，没有度为1的结点
总结：
1.在哈夫曼算法中，初始时有n棵二叉树，要经过n-1次合并，最终形成哈夫曼树。
2.经过n-1次合并产生n-1个新结点，且这n-1个新结点都是具有两个孩子的分支结点。
可见：哈夫曼树中共有n+n-1=2n-1个结点，且其所有的分支结点的度均不为1。

//采用顺序存储结构--一维结构数组
//结点类型定义
typedef struct
{
	int weight;
	int parent, lch, rch;
}HTNode,*HuffmanTree;

数组中为了简单，不使用0下标，数组大小2n，下标从1到2n-1

void CreateHuffmanTree(HuffmanTree HT, int n)
{
	//构造哈夫曼树--哈夫曼算法
	if (n <= 1)
	{
		return;
	}
	int m = 2 * n - 1;//数组共2n-1个元素
	HT = new HTNode[m + 1];//0号单元未用，HT[m]表示根结点
	for (int i = 1; i <= m; i++)
	{
		//将2n-1个元素的lch、rch、parent置为0
		HT[i].lch = 0;
		HT[i].rch = 0;
		HT[i].parent = 0;
	}
	for (int i = 1; i <= n; i++)
	{
		//输入前n个元素的weight值
		cin >> HT[i].weight;
	}
	//初始化结束，下面开始建立哈夫曼树
	for (int i = n + 1; i <= m; i++)
	{
		//合并产生n-1个结点--构造哈夫曼树
		Select(HT, i - 1, s1, s2);//在HT[k](1≤k≤i-1)中选择两个其双亲域为0，且权值最小的点，并返回他们在HT中的序号s1和s2
		HT[s1].parent = i;//白哦是从F中删除s1,s2
		HT[s2].parent = i;
		HT[i].lch = s1;//s1，s2分别作为i的左右孩子
		HT[i].rch = s2;
		HT[i].weight = HT[s1].weight + HT[s2].weight;//i是权值为左右孩子权值之和
	}
}

哈夫曼编码

void CreatHuffmanCode(HuffmanTree HT, HuffmanCode& HC, int n)
{
	//从叶子到根逆向求每个字符的哈夫曼编码，存储在编码表HC中
	HC = new char* [n + 1];//分配n个字符编码的头指针矢量
	cd = new char[n];//分配临时存储编码的动态数组空间
	cd[n - 1] = '/0';//编码结束符
	for (i = 1; i <= n; i++)
	{
		//逐个字符求哈夫曼编码
		start = n - 1;
		c = i;
		f = HT[i].parent;
		while (f != 0)
		{
			//从叶子结点开始向上回溯，直到根结点
			--start;//回溯一次start向前指一个位置
			if (HT[f].lchild == c)
				cd[start] = '0';//结点c是f的左孩子，则生成代码0
			else
				cd[start] = '1';//结点c是f的右孩子，则生成代码1
			c = f;
			f = HT[f].parent;//继续向上回溯
		}//求出第i个字符的编码
		HC[i] = new char[n - start];//为第i个字符串编码分配空间
		strcpy(HC[i], &cd[start]);//将求得的编码从临时空间cd复制到HC的当前行中
	}
	delete cd;//释放临时空间
}

编码和解码