线索二叉树 

  1. #define _CRT_SECURE_NO_WARNINGS
  3. #include "string.h"
  4. #include "stdio.h"    
  5. #include "stdlib.h"   
  6. #include "io.h"  
  7. #include "math.h"  
  8. #include "time.h"
  10. #define OK 1
  11. #define ERROR 0
  12. #define TRUE 1
  13. #define FALSE 0
  15. #define MAXSIZE 100 /* 存储空间初始分配量 */
  17. typedef int Status;	/* Status是函数的类型,其值是函数结果状态代码,如OK等 */
  18. typedef char TElemType;
  19. typedef enum { Link, Thread } PointerTag;	/* Link==0表示指向左右孩子指针, */
  20. /* Thread==1表示指向前驱或后继的线索 */
  21. typedef  struct BiThrNode	/* 二叉线索存储结点结构 */
  22. {
  23. 	TElemType data;	/* 结点数据 */
  24. 	struct BiThrNode *lchild, *rchild;	/* 左右孩子指针 */
  25. 	PointerTag LTag;
  26. 	PointerTag RTag;		/* 左右标志 */
  27. } BiThrNode, *BiThrTree;
  29. TElemType Nil = '#'; /* 字符型以空格符为空 */
  31. Status visit(TElemType e)
  32. {
  33. 	printf("%c ", e);
  34. 	return OK;
  35. }
  37. /* 按前序输入二叉线索树中结点的值,构造二叉线索树T */
  38. /* 0(整型)/空格(字符型)表示空结点 */
  39. Status CreateBiThrTree(BiThrTree *T)
  40. {
  41. 	TElemType h;
  42. 	scanf("%c", &h);
  44. 	if (h == Nil)
  45. 		*T = NULL;
  46. 	else
  47. 	{
  48. 		*T = (BiThrTree)malloc(sizeof(BiThrNode));
  49. 		if (!*T)
  50. 			exit(OVERFLOW);
  51. 		(*T)->data = h; /* 生成根结点(前序) */
  52. 		CreateBiThrTree(&(*T)->lchild); /* 递归构造左子树 */
  53. 		if ((*T)->lchild) /* 有左孩子 */
  54. 			(*T)->LTag = Link;
  55. 		CreateBiThrTree(&(*T)->rchild); /* 递归构造右子树 */
  56. 		if ((*T)->rchild) /* 有右孩子 */
  57. 			(*T)->RTag = Link;
  58. 	}
  59. 	return OK;
  60. }
  62. BiThrTree pre; /* 全局变量,始终指向刚刚访问过的结点 */
  63. /* 中序遍历进行中序线索化 */
  64. void InThreading(BiThrTree p)
  65. {
  66. 	if (p)
  67. 	{
  68. 		InThreading(p->lchild); /* 递归左子树线索化 */
  69. 		if (!p->lchild) /* 没有左孩子 */
  70. 		{
  71. 			p->LTag = Thread; /* 前驱线索 */
  72. 			p->lchild = pre; /* 左孩子指针指向前驱 */
  73. 		}
  74. 		if (!pre->rchild) /* 前驱没有右孩子 */
  75. 		{
  76. 			pre->RTag = Thread; /* 后继线索 */
  77. 			pre->rchild = p; /* 前驱右孩子指针指向后继(当前结点p) */
  78. 		}
  79. 		pre = p; /* 保持pre指向p的前驱 */
  80. 		InThreading(p->rchild); /* 递归右子树线索化 */
  81. 	}
  82. }
  84. /* 中序遍历二叉树T,并将其中序线索化,Thrt指向头结点 */
  85. Status InOrderThreading(BiThrTree *Thrt, BiThrTree T)
  86. {
  87. 	*Thrt = (BiThrTree)malloc(sizeof(BiThrNode));
  88. 	if (!*Thrt)
  89. 		exit(OVERFLOW);
  90. 	(*Thrt)->LTag = Link; /* 建头结点 */
  91. 	(*Thrt)->RTag = Thread;
  92. 	(*Thrt)->rchild = (*Thrt); /* 右指针回指 */
  93. 	if (!T) /* 若二叉树空,则左指针回指 */
  94. 		(*Thrt)->lchild = *Thrt;
  95. 	else
  96. 	{
  97. 		(*Thrt)->lchild = T;
  98. 		pre = (*Thrt);
  99. 		InThreading(T); /* 中序遍历进行中序线索化 */
  100. 		pre->rchild = *Thrt;
  101. 		pre->RTag = Thread; /* 最后一个结点线索化 */
  102. 		(*Thrt)->rchild = pre;
  103. 	}
  104. 	return OK;
  105. }
  107. /* 中序遍历二叉线索树T(头结点)的非递归算法 */
  108. Status InOrderTraverse_Thr(BiThrTree T)
  109. {
  110. 	BiThrTree p;
  111. 	p = T->lchild; /* p指向根结点 */
  112. 	while (p != T)
  113. 	{ /* 空树或遍历结束时,p==T */
  114. 		while (p->LTag == Link)
  115. 			p = p->lchild;
  116. 		if (!visit(p->data)) /* 访问其左子树为空的结点 */
  117. 			return ERROR;
  118. 		while (p->RTag == Thread&&p->rchild != T)
  119. 		{
  120. 			p = p->rchild;
  121. 			visit(p->data); /* 访问后继结点 */
  122. 		}
  123. 		p = p->rchild;
  124. 	}
  125. 	return OK;
  126. }
  128. int main()
  129. {
  130. 	BiThrTree H, T;
  131. 	printf("请按前序输入二叉树(如:'ABDH##I##EJ###CF##G##')\n");
  132. 	CreateBiThrTree(&T); /* 按前序产生二叉树 */
  133. 	InOrderThreading(&H, T); /* 中序遍历,并中序线索化二叉树 */
  134. 	printf("中序遍历(输出)二叉线索树:\n");
  135. 	InOrderTraverse_Thr(H); /* 中序遍历(输出)二叉线索树 */
  136. 	printf("\n");
  138. 	return 0;
  139. }





posted @ 2015-07-08 23:18  Lucas_1993  阅读(174)  评论(0)    收藏  举报