数据结构---树

                                           **树**

树的知识真的是很多！！！！
（一开始我以为排序内容多呢，跪倒在树面前，）
等九月份再二刷吧！！！！！
下图整体结构框架

感觉比排序多的不是一点点！！！！！

王道中的算法
1.二叉树的链式存储结构

//二叉树的链式存储结构
typedef struct BiTNode{
	ElemType data;//数据域
	struct BiTNode *lchild,*rchild;//左，右孩子指针 
}; 

2.遍历

//先序遍历（记忆） 
void PreOrder(BiTree T)
{
	if(T!=NULL)
	{
		visit(T);//访问根结点
		PreOrder(T->lchild);//访问遍历左子树
		PreOrder(T->rchild);//访问遍历右孩子 
	}
}
//中序遍历（记忆） 
void InOrder(BiTree T)
{
	if(T!=NULL)
	{
		PreOrder(T->lchild);//访问遍历左子树
		visit(T);//访问根结点
		PreOrder(T->rchild);//访问遍历右孩子 
	}
 } 
//后序遍历（记忆） 
void PostOrder(BiTree T)
{
	if(T!=NULL)
	{
		PreOrder(T->lchild);//访问遍历左子树
		PreOrder(T->rchild);//访问遍历右孩子 
		visit(T);//访问根结点
	}
 } 
//中序遍历的非递归算法
void InOrder2(BiTree T)
{
	//二叉树中序遍历的非递归算法，算法需要借助一个栈
	InitStack(S);BiTree p=T;//初始化栈；p是遍历指针
	while(p||!IsEmpty(S)){ //栈不空或p不空时循环 
		if(p){  //根指针进栈，遍历左子树 
			Push(S,p);//每遇到非空二叉树先向左走
			p=p->lchild; 
		}
		else{ //根指针退栈，访问根结点，遍历右子树 
			Pop(S,p);visit(p);
			p=p->rchild;
		}
		 
	} 
} 
//层次遍历(记忆） 
void LevelOrder(BiTree T)
{
	InitQueue(Q);//初始化辅助队列
	BiTree p;
	EnQueue(Q,T);//将根结点入队
	while(!IsEmpty(Q)){//队列不空循环
	    DeQueue(Q,p);//队头元素出队
		visit(p);//访问当前p所指向结点
		if(p->lchild!=NULL)
		   EnQueue(Q,p->lchild);//左子树不空，则左子树入队列
		if(p->rchild!=NULL)
		   EnQueue(Q,p->rchild);//右子树不空，则右子树入队列 
	} 
}

3.线索二叉树

//线索二叉树
//线索二叉树的存储结构
typedef struct ThreadNode{
	ElemType data;//数据元素
	struct ThreadNode *lchild,*rchild;//左，右孩子指针
	int ltag,rtag;//左右线索标志 
}ThreadNode,*ThreadTree;
//中序遍历对二叉树线索化的递归算法
//指针pre指向中序遍历时上一个刚刚访问过的结点，用它来表示各结点访问的前后关系 
void InThread(Thread &p,ThreadTree &pre)
{
	if(p!=NULL){
		InThread(p->lchild,pre);//递归，线索化左子树
		if(p->lchild==NULL){
			//左子树为空，建立前驱线索
			p->lchild=pre;
			p->ltag=1; 
		}
		if(pre!=NULL &&pre->rchild==NULL){
		    pre->rchild=p;//建立前驱结点的后继线索
			pre->rtag=1; 
		}
		pre=p;//标记当前结点成为刚刚访问过的结点
		InThread(p->rchild,pre);//递归，线索化右子树 
	}
 } 
//中序遍历建立中序线索二叉树的主过程算法
void CreateInThread(ThreadTree T)
{
	ThreadTree pre=NULL;
	if(T!=NULL){
		//非空二叉树，线索化
		InThread(T,pre);//线索化二叉树
		pre->rchild=NULL;//处理遍历的最后一个结点
		pre->rtag=1; 
	}
 } 
//线索二叉树的遍历
//求中序线索二叉树中中序序列下的第一个结点
ThreadNode *Firstnode(ThreadNode *p)
{
	while(p->ltag==0) p=p->lchild;//最左下结点（不一定是叶结点）
	return p; 
 } 
//求中序线索二叉树中结点p在中序序列下的后继结点
ThreadNode *Nextnode(ThreadNode *p)
{
	if(p->rtag==0) return Firstnode(p->rchild);
	else return p->rchild;//rtag==1直接返回后继线索 
 } 
//不含头结点的中序线索二叉树的中序遍历算法
void Inorder(ThreadNode *T)
{
	for(ThreadNode *p=Firstnode(T);p!=NULL;p=Nextnode(p))
	visit(p); 
 } 

4.并查集

//并查集的结构定义
#define SIZE 100
int UFSets(SIZE);//集合元素数组（双亲指针数组）
//并查集的初始化操作（S即为并查集）
void Initial(int S[])
{
	for(int i=0;i<size;i++)//每个自成单元素集合 
	  S[i]=-1;
 } 
//Find操作（函数在并查集S中查找并返回包含元素x的树的根）
int Find(int S[],int x)
{
	while(S[x]>=0)//循环寻找x的根
	   x=S[x];
	   return x;//根的S[]小于0 
 } 
//Union操作(函数求两个不相交子集合的并集）
void Union(int S[],int Root1,int Root2) 
{
	//要求Root1与Root2是不相同的，且表示子集合的名字
	S[Root2]=Root1;//将根Root2连接到另一根Root1下面 
}

5.二叉排序树

//二叉排序树
//二叉排序树的查找
BSTNode *BST_Search(BiTree T,ElemType key,BSTNode *&p)
{
	//查找函数返回关键字值为key的结点指针，若不存在，返回NULL
	p=NULL;//p指向被查找结点的双亲，用于插入和删除操作中
	while(T!=NULL && key!=T->data){
		p=T;
		if(key<T->data) T=T->lchild;
		else T=T->rchild;
	} 
	return T;
 } 
//二叉排序树的插入
int BST_Insert(BiTree &T,KeyType k)
{
	//在二叉排序树T中插入一个关键字为k的结点
	if(T==NULL)
	{
		//原树为空，新插入的记录为根结点
		T=(BiTree)malloc(sizeof(BSTNode));
		T->key=k;
		T->lchild=T->rchild=NULL;
		return 1;//返回1，表示成功 
	 } 
	 else if(k==T->key)//树中存在相同关键字的结点
	    return 0;
	 else if(k<T->key)
	    return BST_Insert(T->lchild);//插入T的左子树
	 else
	    return BST_Insert(T->rchild);//插入T的右子树 
}
//二叉排序树的构造
void Creat_BST(BiTree &T,KeyType str[],int n)
{
	//用关键字数组str[]建立一个二叉排序树
	T=NULL;//初始时bt为空树
	int i=0;
	while(i<n){
		//依次将每个元素插入 
		BST_InSert(T,str[i]);
		i++;
	} 
 }