二叉树 ADT接口 遍历算法 常规运算

BTree.h   (结构定义, 基本操作, 遍历)

 1 #define MS 10
 2 
 3 typedef struct BTreeNode{
 4                  char data;
 5                 struct BTreeNode * left
 6                 struct BTreeNode * right;
 7 }BTreeNode;
 8 
 9 
10 BTreeNode* InitBTree();
11      /*初始化二叉树,即把树根指针置空*/
12 BTreeNode* CreateBtree(char *a);
13      /*根据a所指向的二叉树广义表字符串建立对应的存储结构,返回树根指针*/
14 int BTreeEmpty(BTreeNode* BT);
15      /*判断一颗二叉树是否为空,若是则返回1,否则返回0*/
16 void Preorder(BTreeNode * BT);
17      /*先序遍历的递归算法*/
18 void Inorder(BTreeNode * BT);
19      /*中序遍历的地鬼算法*/
20 void Postorder(BTreeNode * BT);
21      /*后序遍历的递归算法*/
22 void Levelorder(BTreeNode* BT);
23      /*按层遍历由BT指针所指向的二叉树*/
24 void Inorder(BTreeNode* BT);
25      /*对二叉树进行中序遍历的非递归算法*/
26 int BTreeDepth(BTreeNode * BT);
27      /*求BT指向的一颗二叉树深度*/
28 char* FindBTree(BTreeNode * BT, char x);
29      /*从BT所指向的二叉树中查找值为x的节点*/
30 void PrintBTree(BTreeNode* BT);
31      /*输出二叉树的广义表表示*/
32 BTreeNode* ClearBTree(BTreeNode* BT);
33      /*清除二叉树中的所有节点,使之成为一颗空树*/

BTree.c   (二叉树的接口实现)

  1 void Preorder(BTreeNode * BT){
  2 
  3      if(BT != NULL){
  4          putchar(BT->data);                   //访问根节点
  5          Preorder(BT->left);                  //先序遍历左子树
  6          Preorder(BT->right);                 //先序遍历右子树
  7     }
  8 }
  9 
 10 void Inorder(BTreeNode * BT){
 11      if(BT != NULL){
 12          Inorder(BT->left);                  //中序遍历左子树
 13          putchar(BT->data);                  //访问根节点
 14          Inoreder(BT->right);                //中序遍历右子树
 15     }
 16 }
 17 
 18 void InorderN(BTreeNode* BT){
 19 /*对二叉树进行中序遍历的非递归算法*/
 20      BTreeNode* s[10];                    //定义用于存储节点指针的栈
 21      int top = -1;                        //定义栈顶指针并赋初值使s栈为空                  
 22      BTreeNode* p = BT;                   //定义指针p并使树根指针为它的初值
 23      while(top != -1 || p != NULL){
 24          /*当栈非空或p指针非空时执行循环*/
 25          while(p != NULL){
 26              /*依次向下访问左子树并使树根指针进栈*/
 27              top++;
 28              s[top] = p;
 29              p = p->left;
 30          }
 31          if(top != -1){
 32          /*树根指针出栈并输出节点的值,接着访问右子树*/
 33              p = s[top];
 34              top--;
 35              putchar(p->data);
 36              p = p->right;
 37          }
 38      } 
 39 }
 40 void Postorder(BTreeNode * BT){
 41      if(BT != NULL){
 42          Postorder(BT->left);                //后序遍历左子树
 43          Postorder(BT->right);               //后序遍历右子树
 44          putchar(BT->data);                  //访问根节点
 45     }
 46 }
 47 void Levelorder(BTreeNode* BT){
 48      /*按层遍历由BT指针所指向的二叉树*/
 49      /*定义队列所使用的数组空间,元素类型为指向节点的指针类型*/
 50      BTreeNode* q[MS];          //MS为事先定义的符号常量
 51      /*定义队首指针和队尾指针,初始均置0表示空队*/
 52      int front = 0, rear = 0;
 53      /*将树根指针进队*/
 54      if(BT != NULL)
 55          rear = (rear + 1) % MS;
 56          q[rear] = BT;
 57      }
 58      /*当队列非空时执行循环*/
 59      while(front !- rear){
 60          BTreeNode* p;  //定义指针变量p
 61          /*使队首指针指向队首
 62 BTreeNode* InitBTree(){
 63      /*初始化二叉树,即把树根指针置空*/
 64             return NULL;
 65 }   
 66 
 67 BTreeNode* CreateBtree(char *a){
 68             /*根据a所指向的二叉树广义表字符串建立对应的存储结构,返回树根指针*/
 69             BTreeNode * p = NULL;
 70             /*定义S数组作为存储根节点指针的栈使用*/
 71             BTreeNode* S[MS];     //MS事先定义的符号常量
 72             /*定义top作为S栈的栈顶指针,初值为-1,表示空栈*/
 73             int top = -1;
 74             /*用k作为处理节点的左子树和右子树的标记,k=1处理左子树,k=2处理右子树*/
 75             int k;
 76             /*用i扫描数组a中存储的二叉树广义表字符串,初值为0*/
 77             int i = 0;
 78             /*把树根指针置为空,即从空树开始建立二叉树,待建立二叉树结束后返回*/
 79             BTreeNode BT = NULL;
 80             /*每循环一次处理一个字符,知道扫描到字符串结束符'\0’为止*/
 81             while(a[i]){
 82                  switch(a[i]){
 83                      case ' ':/*对空格不做任何处理,退出此switch语句*/
 84                      case '(':
 85                          if(top ==  MS-1){
 86                              printf("栈空间太小,需增加MS的值!\n");
 87                              exit(1);
 88                          }
 89                          if(p == NULL){
 90                              printf("p值不能为空,退出程序!\n");
 91                              exit(1);
 92                          }
 93                          top++;
 94                          s[top] = p;
 95                          k = 1;
 96                          p = NULL;
 97                          break;
 98                      case ')':
 99                          if(top == -1){
100                              printf("二叉树广义表字符串有错!\n");
101                              exit(1);
102                              }
103                              top--;
104                              break;    
105                      case ',':
106                          k = 2;
107                          break;
108                      default:
109                          if((a[i] >= 'a' && a[i] <= 'z' ||     a[i] >= 'A' && a[i] <= 'Z')){
110                              p = malloc(sizeof(BTreeNode));
111                              p->data = a[i];
112                              p->left = p->right = NULL;
113                              if(BT == Null) BT = P;
114                              else{
115                                  if(k == 1)s[top]->lef = p;
116                                  else s[top]->right = p;
117 118 119                          else{
120                              printf("广义表字符串出错!\n");
121                              exit(1);
122                          }
123                  }
124                  /*为扫描下一个字符修改i值*/
125                  i++;
126              }
127               return BT;
128 }             
129 int BTreeEmpty(BTreeNode* BT){
130      /*判断一颗二叉树是否为空,若是则返回1,否则返回0*/
131      if(BT== NULL) return 1132      else return 0;
133 }
134                 
135 int BTreeDepth(BTreeNode * BT){
136      /*求BT指向的一颗二叉树深度*/
137      if(BT != NULL) return 0;
138      else{
139          /*计算左子树深度*/
140          int dep1 = BTreeDepth(BT->left);
141          /*计算右子树深度*/
142          int dep1 = BTreeDepth(BT->right);
143          
144          /*返回树的深度*/
145          if(dep1 > dep2) return dep1 + 1;
146          else  return dep2 + 1;
147     }
148 }
149 
150 char* FindBTree(BTreeNode * BT, char x){
151      /*从BT所指向的二叉树中查找值为x的节点*/
152          if(BT == NULL) return  NULL;
153          else{
154        /*树节点的值等于x则返回元素地址*/
155              if(BT->data == x) return &(BT->data);
156              else{
157                  char* p;
158         /*向左子树查找若成功则继续返回元素的地址*/
159                  if(p = FindBTree(BT->left,x)) return p;
160         /*向右子树查找若成功则继续返回元素的地址*/
161                  if(p = FindBTree(BT->right,x)) return p;
162         /*左右子树查找均失败则返回空*/
163                  return NULL;
164              }
165          }
166 }
167 
168 void PrintBTree(BTreeNode* BT){
169   /*输出二叉树的广义表表示*/
170      /*树为空时自然结束递归,否则执行如下操作*/
171      if(BT != NULL){
172      /*输出根节点的值*/
173          putchar(BT->data);
174      /*输出左右子树*/
175          if(BT->left != NULL || BT->right != NULL){
176              putchar('(');                           //输出左括号
177              PrintBTree(BT->left);                   //输出左子树
178              if(BT->right != NULL) putchar(',');     //若右子树不为空则输出逗号分隔符
179              
180              PrintBTree(BT -> right);                //输出右子树
181              putchar(')');                           //输出右括号
182          }
183      }
184 }
185 
186 BTreeNode* ClearBTree(BTreeNode* BT){
187              if(BT == NULL) return NULL;
188              else{
189                   ClearBTree(BT->left);              //删除左子树
190                   ClearBTree(BT->right);             //删除右子树
191                   free(BT);                          //释放根节点
192                   return NULL;                       //返回空指针      
193              }
194 }

BTreeTest.c   (二叉树运算调试程序)

 1 #include "BTree.h"
 2 
 3 int main(void){
 4      BTreeNode *p;
 5      char *k;
 6      int n1;
 7      char *a = "A(B(C),D(E(F,G),H(,I)))";
 8      P = InitBTree();                              //建立空树
 9      p = CreateBTree(a);                           //按照广义表形式的二叉树建立二叉链表
10      Preorder(p); putchar('\n');                   //先序遍历
11      Inorder(p)   putchar('\n');                                  //中序遍历 
12      Postorder(p)  putchar('\n');                    //后序遍历
13      Levelorder(p)  putchar('\n');                    //按层遍历
14      InorderN(p)  putchar('\n');                             //中序非递归遍历
15      printf("%d\n",BTreeDepth(p));                           //求二叉树深度
16      k = FindBTree(p, 'I'); if(k!=NULL) printf("%c\n", *k);   //查找二叉树
17      PrintBTree(p);                                       //输出二叉树
18      p = ClearBTree(p);                                   //清空二叉树
19      n1 = BTreeEmpty(P);  printf("%d\n", n1);             //判断树是否为空
20      
21      }

 

posted on 2018-11-11 09:20  MACHINE_001  阅读(447)  评论(0编辑  收藏  举报

导航