3.1 层次关系结构：树(1)

  1 #include <stdio.h> 
  2 #include <stdlib.h> 
  3 #define QUEUE_MAXSIZE 50
  4 typedef char DATA;       //定义元素类型 
  5 typedef struct ChainTree  //定义二叉树结点类型 
  6 {
  7     DATA data;    //元素数据
  8     struct ChainTree *left;    //左子树结点指针
  9     struct ChainTree *right;    //右子树结点指针
 10 }ChainBinTree;
 11 ChainBinTree *BinTreeInit(ChainBinTree *node) //初始化二叉树根结点 
 12 {
 13      if(node!=NULL) //若二叉树根结点不为空 
 14          return node;
 15      else
 16          return NULL;
 17 }
 18 int BinTreeAddNode(ChainBinTree *bt,ChainBinTree *node,int n) //添加数据到二叉树 
 19 //bt为父结点，node为子结点,n=1表示添加左子树，n=2表示添加右子树 
 20 {
 21     if(bt==NULL)
 22     {
 23         printf("父结点不存在，请先设置父结点!\n");
 24         return 0;
 25     } 
 26     switch(n)
 27     {
 28         case 1: //添加到左结点 
 29             if(bt->left) //左子树不为空 
 30             {
 31                 printf("左子树结点不为空!\n");
 32                 return 0;
 33             }else
 34                 bt->left=node;
 35             break;
 36         case 2://添加到右结点
 37             if( bt->right) //右子树不为空 
 38             {
 39                 printf("右子树结点不为空!\n"); 
 40                 return 0;
 41             }else
 42                 bt->right=node;
 43             break;
 44         default:
 45             printf("参数错误!\n");
 46             return 0;
 47     }
 48     return 1;
 49 }
 50 ChainBinTree *BinTreeLeft(ChainBinTree *bt) //返回左子结点 
 51 {
 52     if(bt)
 53         return bt->left;
 54     else
 55         return NULL;
 56 }
 57 ChainBinTree *BinTreeRight(ChainBinTree *bt) //返回右子结点 
 58 {
 59     if(bt)
 60         return bt->right;
 61     else
 62         return NULL;
 63 }
 64 int BinTreeIsEmpty(ChainBinTree *bt) //检查二叉树是否为空，为空则返回1,否则返回0 
 65 {
 66     if(bt)
 67         return 0;
 68     else
 69         return 1;
 70 } 
 71 int BinTreeDepth(ChainBinTree *bt) //求二叉树深度
 72 {
 73     int dep1,dep2;
 74     if(bt==NULL)
 75         return 0; //对于空树，深度为0
 76     else
 77     {
 78         dep1 = BinTreeDepth(bt->left); //左子树深度 (递归调用)
 79         dep2 = BinTreeDepth(bt->right); //右子树深度 (递归调用)
 80         if(dep1>dep2)
 81            return dep1 + 1; 
 82         else
 83             return dep2 + 1; 
 84     } 
 85 } 
 86 ChainBinTree *BinTreeFind(ChainBinTree *bt,DATA data) //在二叉树中查找值为data的结点 
 87 {
 88     ChainBinTree *p;
 89     if(bt==NULL)
 90         return NULL;
 91     else
 92     {
 93         if(bt->data==data)
 94             return bt; 
 95         else{ // 分别向左右子树递归查找 
 96             if(p=BinTreeFind(bt->left,data))
 97                 return p;
 98             else if(p=BinTreeFind(bt->right, data)) 
 99                 return p;
100             else
101                 return NULL; 
102         } 
103     } 
104 } 
105 void BinTreeClear(ChainBinTree *bt) // 清空二叉树，使之变为一棵空树
106 {
107      if(bt)
108      {
109          BinTreeClear(bt->left); //清空左子树 
110          BinTreeClear(bt->right);//清空右子树 
111          free(bt);//释放当前结点所占内存 
112          bt=NULL;
113      }
114      return; 
115 }
116 void BinTree_DLR(ChainBinTree *bt,void (*oper)(ChainBinTree *p))  //先序遍历 
117 {     
118      if(bt)//树不为空，则执行如下操作 
119      {
120          oper(bt); //处理结点的数据 
121          BinTree_DLR(bt->left,oper);
122          BinTree_DLR(bt->right,oper);
123      }
124      return; 
125 } 
126 void BinTree_LDR(ChainBinTree *bt,void(*oper)(ChainBinTree *p))  //中序遍历 
127 {
128      if(bt)//树不为空，则执行如下操作 
129      {
130          BinTree_LDR(bt->left,oper); //中序遍历左子树
131          oper(bt);//处理结点数据 
132          BinTree_LDR(bt->right,oper); //中序遍历右子树/
133      }
134      return; 
135 } 
136 void BinTree_LRD(ChainBinTree *bt,void (*oper)(ChainBinTree *p)) //后序遍历
137 {
138      if(bt)
139      {
140          BinTree_LRD(bt->left,oper); //后序遍历左子树 
141          BinTree_LRD(bt->right,oper); //后序遍历右子树/
142          oper(bt); //处理结点数据
143      }
144      return; 
145 }
146 
147 void oper(ChainBinTree *p) //操作二叉树结点数据 
148 {
149      printf("%c ",p->data); //输出数据
150      return;
151 }
152 
153 void BinTree_Level(ChainBinTree *bt,void (*oper)(ChainBinTree *p)) //按层遍历 
154 {
155      ChainBinTree *p;
156      ChainBinTree *q[QUEUE_MAXSIZE]; //定义一个顺序栈 
157      int head=0,tail=0;//队首、队尾序号 
158      if(bt)//若队首指针不为空     
159      {
160          tail=(tail+1)%QUEUE_MAXSIZE;//计算循环队列队尾序号 
161          q[tail] = bt;//将二叉树根指针进队
162      }
163      while(head!=tail) //队列不为空，进行循环 
164      {
165          head=(head+1)%QUEUE_MAXSIZE; //计算循环队列的队首序号 
166          p=q[head]; //获取队首元素 
167          oper(p);//处理队首元素 
168          if(p->left!=NULL) //若结点存在左子树，则左子树指针进队 
169          {
170              tail=(tail+1)%QUEUE_MAXSIZE;//计算循环队列的队尾序号 
171              q[tail]=p->left;//将左子树指针进队 
172          }
173                  
174          if(p->right!=NULL)//若结点存在右孩子，则右孩子结点指针进队 
175          {
176              tail=(tail+1)%QUEUE_MAXSIZE;//计算循环队列的队尾序号 
177              q[tail]=p->right;//将右子树指针进队 
178          }
179      }
180      return; 
181 }

  1 #include <stdio.h> 
  2 #include "3-1 BinTree.c"
  3 void oper(ChainBinTree *p) //操作二叉树结点数据 
  4 {
  5      printf("%c ",p->data); //输出数据
  6      return;
  7 }
  8 ChainBinTree *InitRoot()  //初始化二叉树的根 
  9 {
 10     ChainBinTree *node;
 11     if(node=(ChainBinTree *)malloc(sizeof(ChainBinTree))) //分配内存
 12     {
 13         printf("\n输入根结点数据:");
 14         scanf("%s",&node->data);
 15         node->left=NULL;
 16         node->right=NULL;
 17         return BinTreeInit(node);
 18     }
 19     return NULL;
 20 }
 21 void AddNode(ChainBinTree *bt)
 22 {
 23      ChainBinTree *node,*parent;
 24      DATA data;
 25      char select;
 26     if(node=(ChainBinTree *)malloc(sizeof(ChainBinTree))) //分配内存
 27     {
 28         printf("\n输入二叉树结点数据:");
 29         fflush(stdin);//清空输入缓冲区 
 30         scanf("%s",&node->data);
 31         node->left=NULL; //设置左右子树为空 
 32         node->right=NULL;
 33         
 34 
 35         printf("输入父结点数据:");
 36         fflush(stdin);//清空输入缓冲区 
 37         scanf("%s",&data);
 38         parent=BinTreeFind(bt,data);//查找指定数据的结点 
 39         if(!parent)//若未找到指定数据的结点 
 40         {
 41             printf("未找到父结点!\n");
 42             free(node); //释放创建的结点内存 
 43             return;
 44          }
 45          printf("1.添加到左子树\n2.添加到右子树\n");
 46          do{
 47             select=getch();
 48             select-=‘0‘;
 49             if(select==1 || select==2)
 50                 BinTreeAddNode(parent,node,select); //添加结点到二叉树 
 51          }while(select!=1 && select!=2);
 52     }
 53     return ;
 54 }
 55 int main() 
 56 {
 57     ChainBinTree *root=NULL; //root为指向二叉树根结点的指针 
 58     char select;
 59     void (*oper1)(); //指向函数的指针 
 60     oper1=oper; //指向具体操作的函数 
 61     do{
 62         printf("\n1.设置二叉树根元素    2.添加二叉树结点\n");
 63         printf("3.先序遍历            4.中序遍历\n");
 64         printf("5.后序遍历            6.按层遍历\n");
 65         printf("7.二叉树深度          0.退出\n");
 66         select=getch();
 67         switch(select){
 68         case ‘1‘: //设置根元素 
 69              root=InitRoot();
 70              break;
 71         case ‘2‘: //添加结点 
 72              AddNode(root);
 73              break;
 74         case ‘3‘://先序遍历
 75              printf("\n先序遍历的结果：");
 76              BinTree_DLR(root,oper1);
 77              printf("\n");
 78              break;
 79         case ‘4‘://中序遍历 
 80              printf("\n中序遍历的结果：");
 81              BinTree_LDR(root,oper1);
 82              printf("\n");
 83              break;
 84         case ‘5‘://后序遍历 
 85              printf("\n后序遍历的结果：");
 86              BinTree_LRD(root,oper1);
 87              printf("\n");
 88              break;
 89         case ‘6‘://按层遍历
 90              printf("\n按层遍历的结果：");
 91              BinTree_Level(root,oper1);
 92              printf("\n");
 93              break;
 94         case ‘7‘://二叉树的深度
 95             printf("\n二叉树深度为:%d\n",BinTreeDepth(root));
 96             break; 
 97         case ‘0‘:
 98              break;
 99         }
100     }while(select!=‘0‘);
101     BinTreeClear(root);//清空二叉树 
102     root=NULL;
103     getch();
104     return 0;
105 }