树的创建和遍历，线索二叉树的创建和遍历

#include <stdio.h>

typedef int elemtype;
define MAX 20


typedef struct BiTree
{
	elemtype m_value;
	struct BiTree* lchild;
	struct Bitree* rchild;
}*tree;

void print_tree(tree T, int order)
{
	if (T == NULL)      //为空直接返回
	{
		return;
	}

	switch (order)
	{
		case 1:      //前序遍历
			printf("%d  ", T->m_value);
			print_tree(T->lchild, order);
			print_tree(T->rchild, order);
			break;
		case 2:		//中序遍历
			print_tree(T->lchild, order);
			printf("%d  ", T->m_value);
			print_tree(T->rchild, order);
			break;
		case 3:		//后序遍历
			print_tree(T->lchild, order);
			print_tree(T->rchild, order);		
			printf("%d  ", T->m_value);
			break;
	}
}

void levelvisit(struct TreeNode* root)   //层序遍历！
{
	tree p;
	int front = 0;
	int rear = 0;
	tree array[MAX];    //建立一个存放树相应节点的指针数组！
	
	if (root != NULL)//先存入一个root
	{
		//根元素入队
		array[rear] = root;
		rear = (rear + 1) % MAX;
	}
	while (front != rear)//rear是用来存储相应的树中的内容和结尾的标志，front则是用来输出对应的内容。
	{
		p = array[front];    
		front = (front + 1) % MAX;
		printf("%c\t", p->value);   
		if (NULL != p->left)         //按相应的规律将节点存入数组中，输出按规律遍历数组就行！
		{
			array[rear] = p->left;
			rear = (rear + 1) % MAX;
		}
		if (NULL != p->right)
		{
			array[rear] = p->right;
			rear = (rear + 1) % MAX;
		}
	}
}

void create_tree(tree* T, int order)
{
	elemtype value;
	scanf("%d", &value);
	if (0 == value)      //给出结束构造的条件
	{
		*T = NULL;    //指向空！
	}
	else
	{
		//先构造结构体空间
		*T = (tree)malloc(sizeof(struct BiTree));
		if (!*T)
		{
			exit(1);    //构造空间失败
		}

		switch (order)
		{
			case 1:            //前序插入
				(*T)->m_value = value;
				create_tree(&(*T)->lchild, order);
				create_tree(&(*T)->rchild, order);
				break;
			case 2:           //中序插入
				create_tree(&(*T)->lchild, order);
				(*T)->m_value = value;
				create_tree(&(*T)->rchild, order);
				break;
			case 3:           //后序插入
				create_tree(&(*T)->lchild, order);
				create_tree(&(*T)->rchild, order);
				(*T)->m_value = value;
				break;
		}
	}
}

//释放堆空间
void free_tree(tree T)
{
	if (T == NULL)
	{
		return;
	}

	free_tree(T->lchild);
	free_tree(T->rchild);		
	free(T);
	printf("free!\n");
}

int main()
{
	tree T;
	int order = 0;
	printf("请选择构建方式： ");
	scanf("%d", &order);
	create_tree(&T, order);

	printf("请选择遍历方式： ");
	scanf("%d", &order);
	print_tree(T, order);

	free_tree(T);

	return 0;
}

线索二叉树：

#include <stdio.h>

typedef int elemtype;

typedef enum {Link, Thread} PointerTag;    /*使用一个枚举类型，Link为表示指向子树，Thread表示指向线索*/



typedef struct BiTree
{
	elemtype m_value;
	struct BiTree* lchild;
	struct Bitree* rchild;
	PointerTag ltag;    // 右标志
	PointerTag rtag;    // 左标志
}*tree;

struct BiTree* pre = NULL;  //全局变量，在转换线索二叉树时，令其始终指向刚刚访问过的节点！

void print_tree(tree T, int order)
{
	if (T == NULL)      //为空直接返回
	{
		return;
	}

	switch (order)
	{
		case 1:      //前序遍历
			printf("%d  ", T->m_value);
			print_tree(T->lchild, order);
			print_tree(T->rchild, order);
			break;
		case 2:		//中序遍历
			print_tree(T->lchild, order);
			printf("%d  ", T->m_value);
			print_tree(T->rchild, order);
			break;
		case 3:		//后序遍历
			print_tree(T->lchild, order);
			print_tree(T->rchild, order);		
			printf("%d  ", T->m_value);
			break;
	}
}

void create_tree(tree* T, int order)
{
	elemtype value;
	scanf("%d", &value);
	if (0 == value)      //给出结束构造的条件
	{
		*T = NULL;    //指向空！
	}
	else
	{
		//先构造结构体空间
		*T = (tree)malloc(sizeof(struct BiTree));
		if (!*T)
		{
			exit(1);    //构造空间失败
		}

		switch (order)
		{
			case 1:            //前序插入
				(*T)->m_value = value;
				create_tree(&(*T)->lchild, order);
				create_tree(&(*T)->rchild, order);
				break;
			case 2:           //中序插入
				create_tree(&(*T)->lchild, order);
				(*T)->m_value = value;
				create_tree(&(*T)->rchild, order);
				break;
			case 3:           //后序插入
				create_tree(&(*T)->lchild, order);
				create_tree(&(*T)->rchild, order);
				(*T)->m_value = value;
				break;
		}
	}
}

void Intreading(tree p)    //将已创建的二叉树变成线索二叉树
{
	if (p == NULL)
	{
		return;
	}
	//使用中序遍历转换成线索二叉树
	Intreading(p->lchild);
	//判断是否存在左子树，如果不存在，则令该节点的左子树指针指向该节点的前驱！
	if (!p->lchild)
	{
		p->ltag = Thread;
		p->lchild = pre;    //因为pre始终指向刚刚访问过的节点，则正在访问的节点的前驱就是pre!
	}
	//判断是否存在右子树，如果不存在，则令该节点的右子树指针指向该节点的后继！
	if (!p->rchild)
	{
		p->rtag = Thread;
	}

	pre->rchild = p;    //因为pre始终指向刚刚访问过的节点，即正在访问的节点是刚刚访问过的节点的后继！
	
	pre = p;                //判断结束，令pre等于现在的节点p
	Intreading(p->rchild);
}

void InorderTraverse_Thr(tree T)
{
	tree p = T;
	while (p != NULL)
	{
		while (p->ltag == Link)   //找到第一个输出的节点
		{
			p = p->lchild;
		}
		printf("%d  ", p->m_value);
		while (p->rtag == Thread && p->rchild != NULL)
		{
			p = p->rchild;
			printf("%d  ", p->m_value);
		}
		p = p->rchild;
	}
}

//释放堆空间
void free_tree(tree T)
{
	if (T == NULL)
	{
		return;
	}

	free_tree(T->lchild);
	free_tree(T->rchild);		
	free(T);
	printf("free!\n");
}

int main()
{
	pre =  (struct BiTree*)malloc(sizeof(struct BiTree));
	tree T;
	int order = 0;
	printf("请选择构建方式： ");
	scanf("%d", &order);
	create_tree(&T, order);

	printf("请选择遍历方式： ");
	scanf("%d", &order);
	print_tree(T, order);
	printf("\n");

	printf("是否指向头结点：%d\n ", T->m_value);

	Intreading(T);
	InorderTraverse_Thr(T);
	printf("\n");


	free_tree(T);

	return 0;
}