二叉树

//先序遍历递归算法
void PreOrder(BiTree T){
	if(T!=Null){
		visit(T);
		PreOrder(T->lchild);
		PreOrder(T->rchild);
	}
} 

//中序遍历递归算法
void InOrder(BiTree T){
	if(T!=Null){
		InOrder(T->lchild);
		visit(T);
		InOrder(T->rchild);
	}
} 

//后序遍历递归算法
void  PostOrder(BiTree T){
	if(T!=NULL){
		PostOrder(T->lchild);
		PostOrder(T->rchild);
		vist(T);
	}
}

//中序遍历的非递归算法
void InOrder2(BiTree T){
	InitStack(S);
	BiTree p=T;
	while(p||!IsEmpty(S)){
		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(!IsQueue(Q)){
		DeQueue(Q,p);
		visit(p);
		if(p->lchild!=NULL)
			EnQueue(Q,p->lchild);
		if(p->rchild!=NULL)
			EnQueue(Q,p->rchild);
	}
} 

//线索二叉树的存储结构描述
typedef struct ThreadNode{
	ElemType data;
	struct ThreadNode *lchild,*rchild;
	int ltag,rtag;
}ThreadNode,*ThreadTree; 

//中序遍历对二叉树线索化的递归算法
void Inthread(ThreadTree &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 GreateInThread(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);
	else return p->rchild;		//直接返回后继线索 
}

//不含头结点的中序线索二叉树的中序遍历的算法 
void InOrder(ThreadNode *T){
	for(ThreadNode *p=FirstNode(T);p!=NULL;p=NextNode(p))
		visit(p);
}

//双亲表示法的存储结构描述 
#define MAX_TREE_SIZE 100
typedef struct{
	ElemType data;
	int parent;
}PTNode;
typedef struct{
	PTNode nodes[MAX_TREE_SIZE];
	int n;
}PTree;

//孩子兄弟表示法的存储结构描述
typedef struct CSNode{
	ElemType data;
	struce CSNode *firstchild,*nextsibling;
}CSNode,*CSTree; 

//并查集的结构定义
#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 Fint(int S[],int x){
	while(S[x]>=0)
		S[x]=x;
	return x;
}

//Union操作（函数求两个不相交子集合的并集） 
void Union(int S[],int Root1,int Root2){
	S[Root2]=Root1;
}

//二叉排序树的非递归查找算法
BSTNode *BST_Search(BiTree T,ElemType key,BSTNode *&p){
	p=NULL;
	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;
	}
	else if(k==T->key)
		return 0;
	else if(k<T->key)
		return BST_Insert(T->lchild,k);
	else
		return BST_Insert(T->rchild,k);
} 

//二叉排序树的构造
void Creat_BST(BiTree &T,KeyType str[],int n){
//用关键字数组str[]建立一个二叉排序树 
	T=NULL;
	int i=0;
	while(i<n){
		BST_Insert(T,str[i]);
		i++;
	}
}