数据结构——树

基础知识：

树是一种非线性的数据结构，它表现的关系是一对多

它是由n（n>=0）个结点组成的有限集，当n = 0时，称为空树。

在任意一棵非空树中应满足：

1、有且仅有一个特殊的根节点，根节点没有前驱结点

2、每一个非根结点有且只有一个父结点；

   除了根结点外，每个子结点可以分为多个不相交的子树，并且子树是不相交的

3、树是递归定义的

4、一颗N个结点的树有N-1条边

结点的度：一个结点含有子树的个数称为该结点的度
树的度：一棵树中，所有结点度的最大值称为树的度
树的深度：一棵树中节点的最大深度就是树的深度，也称为高度
父节点：若一个节点含有子节点，则这个节点称为其子节点的父节点
子节点：一个节点含有的子树的根节点称为该节点的子节点
节点的层次：从根节点开始，根节点为第一层，根的子节点为第二层，以此类推
兄弟节点：拥有共同父节点的节点互称为兄弟节点
叶子节点：度为零的节点就是叶子节点
祖先：从根到该结点所经分支上的所有结点；
子孙：以某结点为根的子树中任一结点都称为该结点的子孙。
森林：m颗互不相交的树构成的集合就是森林

一、树节点的存储结构：

1、树节点的顺序存储

struct TreeNode{
	ElemType data;//节点元素
	bool inEmply;//判断是否为叶子节点
}; 

2、树节点的链式存储与初始化

typedef struct BitNode{
	ElemType data;//节点元素 
	struct BitNode *lchild,*rchild;//定义左指针右指针分别指向节点的左孩子右孩子 
}BitNode,*BiTree;

注：

BitNode,*BiTree;//两种表示法的区别是第一个强调节点，第二个强调树 。

void InitTree(BiTree &T){ 
	T->lchild=NULL; 
	T->rchild=NULL; 
} 

注：

&是因为T中修改的数据要被返回。

T->与T.的区别：如果T是指针则用T->，如果T是结构体变量就用T.

二、二叉树的遍历

1、先序遍历

void preOrder(BitTree T){
	if(T!=NULL){
		visit(T);
		preOrder(T->lchild);
		preOrder(T->rchild); 
	}
} 

注：

函数引用变量T时没有加&，是因为这个函数对变量不做修改，只进行访问。

visit(T);这个函数的是访问节点用的，题目或者项目中具体要做什么按需求进行定义。

2、中序遍历

void InOrder(BiTree T){
	if(T!=NULL){
		InOrder(T->lchild);
		visit(T);
		InOrder(T->rchild); 
	}
}

3、后序遍历

void PostOrder(BiTree T){
	if(T!=NULL){
		PostOrder(T->lchild);
		PostOrder(T->rchild); 
		visit(T);
	}
}

4、层序遍历

层序遍历与要用到一个辅助队列，当访问一个节点时，将该节点出队，后将该节点的孩子节点入队。

void LevelOreder(BiTree T){
	LinkQueue Q;//定义辅助队列 
	InitQueue(Q);//初始化队列 
	BiTree q;//定义辅助指针q，指向当前树节点 
	EnQueue(Q,T);//将根节点入队 
	while(!isEmpty(Q)){//判断队列是否为空，所还有数据，说明树的节点还没有遍历完 
		DeQueue(Q,q);//将队首元素出队，并且q指向该元素 
		visit(q);//对节点进行待定操作 
		if(q->lchild!=NULL){//节点有左孩子就入队 
			EnQueue(q->lchild);
		}
		if(q->rchild!=NULL){//节点有右孩子就入队 
			EnQueue(q->rchild); 
		}
	}
}

三、树的遍历(使用伪代码的形式)

1、树的先根遍历

先遍历父节点后遍历子节点。

树的先根遍历结果与这棵树对应的二叉树的先序序列相同（深度优先）

void PreOrder(TreeNode *R){
	if(R!=NULL){
		visit(R);
		while(R还有下一个子树T)
			PreOrder(T); 
	}
} 

 while的判断条件的实现：可以在节点的结构体中添加一个变量has，表示该节点的孩子节点的数量。

2、树的后根遍历

先遍历子节点后遍历父节点。

树的后根遍历结果与这棵树对应的二叉树的中序序列相同（深度优先） 

void PostOrder(TreeNode *R){
	if(R!=NULL){
		while(R还有下一个子树T)
			PostOrder(T);
		visit(R);
	}
} 

3、树的层序遍历

用队列实现（广度优先） 

void LevelOreder(TreeNode &R){
	LinkQueue Q;//定义辅助队列 
	InitQueue(Q);//初始化队列 
//	BiTree q;//定义辅助指针q，指向当前节点 
	EnQueue(Q,R);//将根节点入队 
	while(!isEmpty(Q)){//判断队列是否为空，所还有数据，说明树的节点还没有遍历完 
		DeQueue(Q,R);//将队首元素出队，并且q指向该元素 
		visit(q);//对节点进行待定操作 
		for(int i=0;i<子节点的数量；i++){
			EnQueue(Q,q节点的子节点a[i]); 
		}
	}
}

寻找子节点方法：给节点结构体中加入一个数组用来存放指向子节点的指针。

四、树的三种存储结构 

树不同于二叉树那么有规矩，节点可以有多个分支。

1、 顺序存储（树和森林） 

父亲表示法 :适用于找父亲比较多的 
优点：找父亲方便

#define MaxSize 10 
typedef struct Tree_Node{//树的节点定义 
	ElemType data;
	int parent;//双亲位置域（双亲的数组下标）注：根节点位-1 
}; 

typedef struct PTree{
	Tree_Node nodes[MaxSize];
	int n;//用来记录节点数 
}; 

2、顺序存储+链式存储

孩子表示法：适用于找孩子比较多的 
优点：查找孩子方便 

#define maxsize 10 
struct Child_Node{
	int child_index;//孩子的下标值 
	struct Child_Node *next; 
};

typedef struct CTBox{//定义孩子链表 
	ElemType data;
	struct Child_Node *first_node;//第一孩子节点 
};  

typedef struct CTree{
	CTBox nodes[MaxSize];
	int n,r;//节点数和根的位置 
};   

3、链式存储 

孩子兄弟表示法(将普通树转化为二叉树) 
两个指针左指针指向第一个孩子，右指针指向右边第一个兄弟

typedef struct CSNode{
	ElemType data;
	struct CSNode *firstchild,*nextsibling;//左孩子右兄弟 
}; 

五、树的应用——并查集

原理就是将一棵树使用双亲表示法进行存储。
并操作：将除第一颗树以外的树的根节点的s[]值赋值为第一颗树的根节点下标。
查操作：递归的查出节点的根节点，并进行比较。如果相等，则在同一个集合之中 。

#define Size 13;
int UFStes[Size];//集合元素的数组

1、初始化并查集

void Initial(int S[]){
	for(int i=0;i<Size;i++){
		S[i]=-1;
	}
} 

2、查

时间复杂度O（n） 优化：让 n(树的高度)变小 ——>优化思路就是将树的高度进行压缩 

int Find(int S[],int x){
	while(S[x]>0){//循环递归查找根节点 
		x=S[x];
	}
	return x;
} 

3、查操作优化：压缩路径

查找的同时可以进行优化S[]

int Find(int S[],int x){
	int root=x;
	while(S[root]>=0) root=S[root];//找根 
	while(x!=root){//压缩路径 
		int t=S[x];//t指向x的父亲节点 
		S[x]=root;//x直接挂在根节点上 
		x=t;
	}
	return root;
} 

4、并

时间复杂度O（1） 

void Union(int S[],int Root1,int Root2){//Root1,Root2分别表示所要并操作的两个树的根节点的位置 
	if(Root1==Root2)return ;//确保在不同的集合 
	S[Root2]=Root1;
} 

5、并操作优化

小树并到大树中他的高度不会发生变化，故可以在S[]中存储树的节点个数（但要是负数），如S[i]=-9,说明这个树有就九个节点 ，使得树的高度不超过log2（n）+1,可以提高查的效率 。

void Union(int S[],int Root1,int Root2){
	if(Root1==Root2)return ;
	if(Root1>Root2){
		S[Root1]+=S[Root2];//更新节点个数 
		S[Root2]=Root1;//让小树的父节点指向大树的根节点 
	}else{
		S[Root2]+=S[Root1];
		S[Root1]=Root2;
	}
} 

6、有关并查集题 

和跟植物问题（并查集）