Binary Tree：

 1 #include <stdio.h>
 2 #include <stdlib.h>
 3 
 4 typedef char Elemtype;
 5 
 6 typedef struct BTNode
 7 {
 8     Elemtype data; 
 9     struct BTNode *lchild, *rchild;
10 } BTNode, *BTree;
11 
12 //创建二叉树，约定使用前序遍历的方式输入数据
13 void CreateBTree(BTree *T)
14 {
15     char c;
16     scanf("%c", &c);
17     if(' '==c)
18     {
19         *T = NULL;
20     }
21     else
22     {
23         *T = (BTNode *)malloc(sizeof(BTNode));
24         (*T)->data = c;
25         CreateBTree(&(*T)->lchild);
26         CreateBTree(&(*T)->rchild);
27     }
28 }
29 
30 //访问二叉树的具体操作
31 void visit(Elemtype data, int level)
32 {
33     printf("%c在第%d层\n", data, level);
34 }
35 
36 //前序遍历二叉树
37 void PreOrderTraverse(BTree T, int level)
38 {
39     if (T)
40     {
41         visit(T->data, level);
42         PreOrderTraverse(T->lchild, level + 1);
43         PreOrderTraverse(T->rchild, level + 1);
44     }
45 }
46 
47 int main()
48 {
49     int level = 1;
50     BTree T ;
51     
52     CreateBTree(&T);
53     PreOrderTraverse(T, level);
54 
55     return 0;
56 }

View Code

线索二叉树：

线索：将那些浪费了空间的结点重新利用，使他们的空指针指向他们各自的前驱和后继结点

  1 //Binary Thread Tree 二叉线索树
  2 #include <stdio.h>
  3 #include <stdlib.h>
  4 
  5 typedef char Elemtype;
  6 //线索存储标志位
  7 //Link(0):表示指向左右孩子的指针
  8 //Thread(1):表示指向前驱后继的线索
  9 //enum:枚举类型：第一个枚举成员的默认值为整型的 0，后续枚举成员的值在前一个成员上加 1
 10 typedef enum {Link,Thread} PointerTag;
 11 
 12 
 13 typedef struct BiThrNode
 14 {
 15     Elemtype data; 
 16     struct BiThrNode *lchild, *rchild;
 17     PointerTag ltag;        //左右标志
 18     PointerTag rtag;
 19 } BiThrNode, *BiThrTree;
 20 
 21 //定义全局变量，始终指向刚刚访问过的结点
 22 BiThrTree pre;
 23 
 24 //创建二叉树，约定使用前序遍历的方式输入数据
 25 void CreateBiThrTree(BiThrTree *T)
 26 {
 27     char c;
 28     scanf("%c", &c);
 29 
 30     if(' '==c)
 31     {
 32         *T = NULL;
 33     }
 34     else
 35     {
 36         *T = (BiThrNode *)malloc(sizeof(BiThrNode));
 37         (*T)->data = c;
 38         (*T)->ltag = Link;
 39         (*T)->rtag = Link;
 40         CreateBiThrTree(&(*T)->lchild);
 41         CreateBiThrTree(&(*T)->rchild);
 42     }
 43 }
 44 
 45 //中序遍历线索化
 46 //前驱和后继就是中序遍历的前驱和后继
 47 void InThreading(BiThrTree T)
 48 {
 49     if(T)
 50     {
 51         InThreading(T->lchild);
 52         //线索化
 53         //pre是T的前驱，T是pre的后继
 54         if(!T->lchild)
 55         {
 56             T->ltag = Thread;
 57             T->lchild = pre;
 58         }
 59         if(!pre->rchild)
 60         {
 61             pre->rtag = Thread;
 62             pre->rchild = T;
 63         }
 64         pre = T;
 65         InThreading(T->rchild);
 66     }
 67 }
 68 
 69 //添加了一个头结点p，形成一个双向链表
 70 InOrderThreading(BiThrTree *p,BiThrTree T)
 71 {
 72     *p = (BiThrNode *)malloc(sizeof(BiThrNode));
 73     (*p)->ltag = Link;
 74     (*p)->rtag = Thread;
 75     (*p)->rchild = *p;
 76     if(!T)
 77     {
 78         (*p)->lchild = *p;
 79     }
 80     else
 81     {
 82         (*p)->lchild = T;
 83         pre = *p;       //把头结点赋值给pre
 84         InThreading(T);
 85         //最终的pre是中序遍历的最后一个结点
 86         pre->rchild = *p;
 87         pre->rtag = Thread;
 88         (*p)->rchild = pre;
 89     }
 90 }
 91 
 92 //中序遍历二叉树，非递归
 93 //传进来的是头结点，不是根结点
 94 void InOrderTraverse(BiThrTree T)
 95 {
 96     BiThrTree p;
 97     p = T->lchild;
 98     while(p!=T)
 99     {
100         while(p->ltag==Link)
101         {
102             p = p->lchild;
103         }
104         printf("%c",p->data);
105         while(p->rtag==Thread && p->rchild!=T)
106         {
107             p = p->rchild;
108             printf("%c",p->data);
109         }
110         p = p->rchild;
111     }
112 }
113 
114 int main()
115 {
116     BiThrTree p,T=NULL ;
117     CreateBiThrTree(&T);
118     InOrderThreading(&p,T);
119 
120     printf("中序遍历输出结果为：");
121     InOrderTraverse(p);
122 
123     return 0;
124 }

View Code

好难啊！！！！

记不住