数据结构复习笔记（树）

//1.二叉树链式存储结构
typedef struct BiTreeNode{
	ElemType data;
	struct BiTreeNode *rchild,*lchild;
}BiTreeNode,*BiTree;

//2.先序遍历
void PreOrder(BiTree T){
	if(T!=NULL){
		visit(T);
		PreOrder(T->lchild);
		PreOrder(T->rchild);
	}
}

//3.中序遍历
void InOrder(BiTree T){
	if(T!=NULL){
		InOrder(T->lchild);
		visit(T);
		InOrder(T->rchild);
	}
}

//4.后序遍历
void PostOrder(BiTree T){
	if(T!=NULL){
		PostOrder(T->lchild);
		PostOrder(T->rchild);
		visit(T);
	}
}

//5.中序遍历（非递归算法）
void InOrder2(BiTree T){
	InitStack(S);
	BiTree p=T;
	while(p||!IsEmpty(S)){
		if(p){//p不为空
			Push(S,p);//将p加入栈
			p=p->lchild;//继续向p的左孩子遍历，若p无左孩子则进入else情况
		}else{
			Pop(S,p);//此时取出栈顶元素
			visit(p);//遍历
			p=p->rchild;//向右孩子走，若无右孩子会继续退栈
		}
	}
}

//6.先序遍历（非递归算法）
void PreOrder2(BiTree T){
	InitStack(S);
	BiTree p=T;
	while(p||!IsEmpty(S)){
		if(p){
			visit(p);
			Push(S,p);
			p=p->lchild;
		}else{
			Pop(S,p);
			p=p->rchild;
		}
	}
}

//7.后序遍历（非递归算法）
void PostOrder(BiTree T){
	InitStack(S);
	BiTree p=T;
	BiTree r=NULL;
	while(p||!IsEmpty(S)){
		if(p){
			push(S,p);
			p=p->lchild;
		}else{
			GetTop(S,p);//读栈顶结点
			if(p->rchild && p->rchild!=r)
			//若右子树存在，且未被访问过
				p=p->rchild;//转向右
			else{
				Pop(S,p);//否则，弹出结点并访问
				visit(p);
				r=p;//记录最近访问过的结点
				p=NULL;//结点访问完后，重置p指针
			}
		}
	}
}

//8.层次遍历
void Level_Order(BiTree T){
	InitQueue(Q);
	BiTree p;
	EnQueue(Q,T);
	while(!IsEmpty(Q)){
		DeQueue(Q,p);
		visit(p);
		if(p->lchild!=NULL)
			EnQueue(Q,p->lchild);
		if(p->rchild!=NULL)
			EnQueue(Q,p->rchild);
	}
}

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

//10.中序遍历线索化二叉树
void InThread(ThreadTree &p,ThreadTree &pre){
	if(p!=NULL){
		InThread(p->lchild,pre);
		if(p->lchild==NULL){//左子树为空，建立前驱线索
			p->lchild=pre;
			p->ltag=1;
		}
		if(p->rchild==NULL && pre!=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;
}		

//11.中序线索化二叉树的遍历
ThreadNode *FirstNode(ThreadNode *p){
	while(p->ltag==0) 
		p=p->lchild;
	return p;
}
ThreadNode *NextNode(ThreadNode *p){
	if(p->rtag==0) return FirstNode(p->rchild);//如果有右孩子
	else return p->rchild;//否则返回后继结点
}
void In_Order(ThreadNode *T){
	for(ThreadNode *p=FirstNode(T); p!=NULL; p=NextNode(p))
		visit(p);
}

//12.双亲表示法
#define MAX_TREE_SIZE 100
typedef struct{
	ElemType data;
	int parent;
}PTNode;
typedef struct{
	PTNode nodes[MAX_TREE_SIZE];
	int n;
}PTree;

//13.孩子兄弟表示法
typedef struct CSNode{
	ElemType data;
	struct CSNode *firstchild,*nextsibling;
}CSNode, *CSTree;