先序线索二叉树 ——C源码（测试成功）

//二叉树--链式存储
//先序线索二叉树 
#include <stdio.h>
#include <stdlib.h> 
#define MAXSIZE 100

struct ThreadNode{
	
	//数据域 
	int value; 
	
	//左孩子 
	struct ThreadNode *lChild;
	
	//右孩子 
	struct ThreadNode *rChild;
	
	//1--前驱结点  0--左孩子 
	int ltag;
	
	//1--后继结点  0--右孩子 
	int rtag;
	
}; 

typedef struct ThreadNode ThreadNode;

typedef struct ThreadNode* ThreadTree;


/*
	初始化tree 
*/
ThreadTree* initTree(ThreadTree root){
	
	root=NULL;
	
	return root;
}

/*
	构造树 
*/
ThreadTree* constructTree(ThreadTree root){
	
	ThreadNode *p11=(ThreadNode *)malloc(sizeof(ThreadNode));
	(*p11).ltag=0;
	(*p11).rtag=0;
	(*p11).value=11;
	(*p11).lChild=NULL;
	(*p11).rChild=NULL;
	
	ThreadNode *p12=(ThreadNode *)malloc(sizeof(ThreadNode));
	(*p12).ltag=0;
	(*p12).rtag=0;
	(*p12).value=12;
	(*p12).lChild=NULL;
	(*p12).rChild=NULL;
	
	ThreadNode *p5=(ThreadNode *)malloc(sizeof(ThreadNode));
	(*p5).ltag=0;
	(*p5).rtag=0;
	(*p5).value=5;
	(*p5).lChild=NULL;
	(*p5).rChild=p11;
	
	ThreadNode *p6=(ThreadNode *)malloc(sizeof(ThreadNode));
	(*p6).ltag=0;
	(*p6).rtag=0;
	(*p6).value=6;
	(*p6).lChild=p12;
	(*p6).rChild=NULL;
	
	ThreadNode *p7=(ThreadNode *)malloc(sizeof(ThreadNode));
	(*p7).ltag=0;
	(*p7).rtag=0;
	(*p7).value=7;
	(*p7).lChild=NULL;
	(*p7).rChild=NULL;
	
	ThreadNode *p2=(ThreadNode *)malloc(sizeof(ThreadNode));
	(*p2).ltag=0;
	(*p2).rtag=0;
	(*p2).value=2;
	(*p2).lChild=NULL;
	(*p2).rChild=p5;
	
	ThreadNode *p3=(ThreadNode *)malloc(sizeof(ThreadNode));
	(*p3).ltag=0;
	(*p3).rtag=0;
	(*p3).value=3;
	(*p3).lChild=p6;
	(*p3).rChild=p7;
	
	ThreadNode *p1=(ThreadNode *)malloc(sizeof(ThreadNode));
	(*p1).ltag=0;
	(*p1).rtag=0;
	(*p1).value=1;
	(*p1).lChild=p2;
	(*p1).rChild=p3;
	
	root=p1;
	
	return root;
}


//指向当前被访问的结点 
ThreadNode *q1=NULL;

/*
	创建先序线索二叉树 
*/
void createPreThread(ThreadTree root){
	
	if(root!=NULL){
		preThread(root);
		if((*q1).rChild==NULL){
			(*q1).rtag=1;
		}
	} 
	
}

/*
	先序线索二叉树 
*/
void preThread(ThreadTree root){
	ThreadNode *pre=NULL;
	if(root!=NULL){
		pre=q1;
		q1=root;
		if((*q1).lChild==NULL){
			(*q1).lChild=pre;
			(*q1).ltag=1;
		}
		if(pre!=NULL&&(*pre).rChild==NULL){
			(*pre).rChild=q1;
			(*pre).rtag=1;
		}
		
		if((*root).ltag==0){
			preThread((*root).lChild);
		} 
		preThread((*root).rChild);
	}
}


/*
	找到以p为根的子树中，第一个被先序遍历的结点 
*/ 
ThreadNode* preFirstNode(ThreadNode *p){
	
	if(p!=NULL){
		return p;
	} 
	
	return NULL;
}

/*
	先序线索二叉树中找到结点p的后继结点 
*/
ThreadNode* preNextNode(ThreadNode *p){
	
	//右指针存放的是后继，直接返回 
	if((*p).rtag==1){
		return (*p).rChild;
	}else{
		
		//右指针存放的不是后继 
		
		//判断有没有左孩子，有直接返回，否则返回右孩子 
		if((*p).ltag==0){
			return (*p).lChild;
		}else{
			return (*p).rChild;
		} 
		
	}	
} 

int main(){
	 
	return 0;
}