树和森林(森林的部分已经看不懂了)

树和二叉树
树的概念:
结构特点:有且仅有一个根节点无前驱,有一个或多个叶节点无后继
其余结点有唯一前驱和若干后继

递归描述:空是树,不空时,树由唯一根节点和若干子树组成,
每个子树满足树的定义

int NodeCount(Tree T)
{
	if (T == NULL) return 0;
	else 
	{
		return 1 + NodeCount(T->lTree) + NodeCount(T->rTree);
	}
}

树的相关术语
空树:
根节点:
叶子结点:
结点的子树
树的子树
结点的度:孩子结点的个数(和图有区别)
树的度
终端结点
非终端结点
内部节点
结点的层次(从1开始)
树的深度
树的宽度
无序树 有序树
Tree = (root, F) F = {T1, …, Tm}
Ti = (ri, Fi)
路径与路径长度(边的个数)
从根节点到任意节点存在唯一路径

树的抽象数据类型定义
数据对象
具有相同特性的数据元素的集合
数据关系
若D为空集,则称为空树
否则:D中存在唯一的称为根的数据元素root
当 n > 1 时,其余结点可分为m个互不相交的有限集
其中每一个子集本身又是一棵符合本定义的树,称为根root的子树

操作合集
InitTree(&T)
Destroy(&T)
InsertChild(&T, &p, i, c)
//插入c为T中p所指结点的第i子树
CreateTree(&T, definition)
CreateTree(&T)
Assign(T, &cure_e, value)
TreeEmpty(T)
TreeDepth(T)
Root(T)
Value(T, cur_e)
Parennt(T, cur_e)`在这里插入代码片`
LeftChild(T, cur_e)
RightSibling(T, cur_e)
//求cur_e结点的右兄弟
TraverseTree(T,visit())

2.1 二叉树
二叉树:度不大于2的有序树(空树也是二叉树)

2.2 二叉树的性质
性质1 二叉树 第i层上最多有 2^(i - 1)个结点
性质2 深度为k的二叉树最多有2^k - 1 个结点
性质3 对任意二叉树 如果度为0的结点个数为n0,
度为2的结点个数为n2,则n0 = n2 + 1
满二叉树:每层结点个数都是最大值
完全二叉树:满二叉树的最后一层最右边缺少了几个叶子结点
性质4 含n个结点的完全二叉树的深度为 下取整[log2n] + 1
下取整只能得到 去掉叶子结点的 满二叉树 的层数 还需要再 +1
性质5 一个节点的编号为i(从1开始), 则左子树根节点的编号为 2 * i
右子树根节点的编号为 2 * i + 1
双亲结点的编号为 下取整[i/2]

二叉树的存储和基本操作
二叉树的连式存储–二叉链表

typedef struct BiTNode
{
	TElemType data;
	struct BiTNode *lTree, *rTree;
}BiTNode, *BiTree;
二叉树的常见操作
创建
Status CreatBiTree(BiTree T)
{
	TElemType e;
	cin >> e;
	if (e == 0) T == NULL;
	else
	{
		T = (BiTNode*)malloc(sizeof(BiTNode));
		if (!T) exit(OVERFLOW);
		T->data = e;
		CreatBiTree(T->lTree);
		CreatBiTree(T->rTree);
	}
	return OK;
}

销毁
(没写, 再说)

求树的结点数
int NodeCount(BiTree T)
{
	if (T == NULL) return 0;
	else return 1 + NodeCount(T->lTree) + NodeCount(T->rTree);
}

求叶子节点数
int LeafCount(BiTree T)
{
	if (T->lTree == NULL && T->rTree == NULL) return 1;
	else 
	{
		LeafCount(T->rTree) + LeafCount(T->rTree);
	}
}

求深度
int getTreeDepth(BiTree T)
{
	if (T == NULL) return 0;
	else
	{
		return 1 + max(getTreeDepth(T->lTree), getTreeDepth(T->rTree));
	}
}
二叉树的连式存储--三叉链表
为了方便求一个节点的双亲
typedef struct TriTNode
{
	struct TriTNode *parent;
	TElemType data;
	struct TriTNode *lTree, *rTree;
}TriTNode, *TriTree;

二叉树的顺序存储
[注意]千万不能只将有值的结点存入顺序表,这样会丢失结构信息
正确的做法是将所有结点,包括无值的结点都要保存
#define MAX_TREE_SIZE 100
typedef struct SqBiTree[MAX_TREE_SIZE];
//鲁老师的办法是零号元素存根节点,但是我认为还是将0号空出来,
//1号位置存根节点比较好

二叉树的遍历
Stauts PreOrderTraverse(BiTree T, Status(*visit)(TElemType))
{
	if (T == NULL) return OK;
	else
	{
		visit(T->data);
		PreOrderTraverse(T->lTree, visit);
		PreOrderTraverse(T->rTree, visit);
		return OK;
	}
}

Status InOrderTraverse(BiTree T, Status(*visit)(TElemType))
{
	if (T == NULL) return OK;
	else 
	{
		InOrderTraverse(T->lTree, visit);
		visit(T->data);
		InOrderTraverse(T->rTree, visit);
		return OK;
	}
}

Status PostOrderTraverse(BiTree T, Staus(*visit)(TElemType))
{
	if (!T) return OK;
	else 
	{
		PostOrderTraverse(T->lTree);
		PostOrderTraverse(T->rTree);
		visit(T->data);
		return OK;
	}
}

表达式树:
从左到右扫描表达式,找到最后一个优先级最低的运算符
将其放在根节点,左侧子表达式作为左子树,右侧子表达式作为右子树:
知道两个子树均为数字停止递归
[注意]小括号的运算等级最高

有遍历序列还原二叉树
先序 + 中序:先序第一个元素x为根,中序中x左侧为x的左子树,
x的右侧必构成右子树;对子树的处理,第一个在先序序列中出现的元素Y
为该左子树的根,中序序列中Y元素左侧构成Y的左子树

中序 + 后序:

先序 + 后序:不确定

二叉树的非递归遍历:
Status InOrderTraverse_NonRec(BiTree T, Status(*visit)(TElemType))
{
	SqStack S;
	InitStack(S);
	Push(S, T);
	while (!StackEmpty(S))
	{
		while (GetTop(S, p) && p) Push(S, p->lTree);
		Pop(S,p);
		if (!StackEmpty(p))
		{
			Pop(S, p);
			(*visit)(p->data);
			Push(S, p->rTree);
		}
	}
	return OK;
}

线索二叉树
背景:如何提高遍历效率

中序线索化一般加头结点, 先序/后序可不加
头结点: [LINK] + lTree + (data) + rTree + [THREAD]
[注意]ppt上没写,但是我认为 头结点的结构和 线索二叉树的结点是一样的
毕竟还是要满足 链式结构的 定义

线索二叉树的结点结构组成: LTag + lTree + data + rTree + RTag
typedef enum{LINK, THREAD}PTag;
LINK:代表指针值是孩子结点的地址(用来存储二叉树的结构信息的)
THREAD:代表值是前驱/后继结点的地址(用来存储链表的结构信息的)
线索二叉树存储结构定义:
typedef struct BiThrNode
{
TElemType data;
struct BiThrNode *lTree, *rTree;
PTag LTag, RTag;
}BiThrNode, *BiThrTree;

中序二叉树的遍历:
重复至p指向头结点
{
找到第一一个应该遍历的点,记入p
访问p->data
只要p->RTag为THREAD(链表地址)则令p沿p->rTree前进
否则,让p指向右子树的根
}
[]个人感觉吧,这个遍历方式,其实应该是先访问中序的最左边的结点,然后
依次访问右边的结点,若当前的结点的右指针是链表地址,那就直接访问该节点,
并且转移到右指针指向的结点(也就是后驱结点),否则,就通过rTree返回到根节点,
然后再判断

void InOrderTraverse(BiThrTree T, Status(*visit)(TElemType))
{
	p = T->child;
	while (p != T)
	{
		//找到第一一个应该遍历的点,记入p
		while (p->LTag == LINK) p = p->lTree;
		if (!visit(p->data)) return ERROR;
		while (p->RTag == THREAD && p->rTree != T)
		{
			p = p->rTree;
			if (!visit(p->data)) return ERROR;
		}
		p = p->rTree;
	}
}

树与森林

1. 树和森林的存储表示
   1.1 树的表示法-双亲表示法
   typedef char TElemType;
   #define MAX_TREE_SIZE 100
   typedef struct PTNode
   {
   TElemType data;
   int parent;
   }PTNode;

typedef struct
{
PTNode nodes[MAX_TREE_SIZE];
int r, n;
}PTree;

1.1 树的表示法-多重链表表示法
(1)
typedef struct TNode
{
TElemType data;
struct TNode[childMAX];
}TNode, *Tree;

typedef struct TNode{
TElemType data;
int degree;
struct TNode *child;
}TNode, *Tree;

1.1 输的表示法-多重链表表示法
//链表结点的定义: 孩子的信息 + 下一个孩子
typedef struct CTNode
{
int child;
struct CTNode *next;
}*ChildPtr;

树的结点: 该节点的信息 + 双亲 + 孩子链表的指针
typedef struct{
TElemType data;
int parent;
ChilPTr firstchild;
}CTBox;

//树的定义
typedef struct{
CTBox nodes[MAX_TREE_SIZE];
int n, r;
}CTree;

1.1 树的表示法-孩子兄弟表示法(二叉树表示)
与二叉树的二叉链表存储结构同构,
但指针含义不同
typedef struct CSNode
{
TElemType data;
struct CSNode *firstchild;
struct CSNode *nextsibling;
}CSTNode, *CSTree;

抽象一下:
结点的左孩子保存第一个结点的地址,
右孩子保存孩子结点的兄弟结点
既然存在这种结构,那就认为他有存在的道理吧

1.2 森林的表示法
typedef struct CSNode
{
TElemType data;
struct CSNode *firstchild;
struct CSNode *nextsibling;
}CSTNode, *CSTree;

把两个分开的树开成是 兄弟
那么根据 孩子兄弟表示法 第一个树的根节点的右孩子
保存了下一个树的根节点, 然后 依次保存 下一棵树的 根节点
每棵树再用孩子兄弟表示法保存其子树

2 树/森林与二叉树之间的转化
2.1 树-二叉链表-二叉树
一棵二叉树 可以转化成 普通的 二叉树
也可以通过孩子兄弟表示法 转换成 多叉树
其中 用孩子兄弟表示法 时:
结点的 右子树的右子树的…都是这个结点的 兄弟
左子树 是该节点的 第一个孩子
再用上述的方法确定 所有 的孩子

2.2 森林-二叉链表-二叉树

3. 树和森林的操作实现
   3.1 树的遍历
   遍历 的话 用 孩子兄弟表示法 存储 树
   树的先根遍历: 遍历二叉链表(先序遍历)
   程序:同二叉树的先序遍历, lchild 与 rchild 换做
   firstchild 和 nextsibling
   遍历序列: 可以直接根据先跟规则写先写根, 然后在一直往下走到底
   在返回上一个结点,到下一个孩子结点, 继续往下走到底

树的后根遍历:遍历孩子兄弟表示的树 = 遍历二叉链表(中序)
程序:同二叉树的中序遍历:lchild与rchild 换做 firstchild 和 nextsibling
遍历序列:可以直接根据后根规则写

3.2 森林的遍历
森林的先序遍历:比那里孩子兄弟表示的森林 = 遍历二叉链表(先序)
程序:同二叉树先序遍历, lchild与rchild换做firstchild和nextsibling
遍历序列:可直接根据先序遍历规则写

森林的中序遍历: (不会,没看懂)

3.3 森林(含树)求深度-分而治之
递归边界:空森林深度为0
递归关系:大参林深度为首棵树的深度和余数森林的深度取最大值
(没看懂)