zoukankan      html  css  js  c++  java
  • 二叉树 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             /*每循环一次处理一个字符,知道扫描到字符串结束符'’为止*/
     81             while(a[i]){
     82                  switch(a[i]){
     83                      case ' ':/*对空格不做任何处理,退出此switch语句*/
     84                      case '(':
     85                          if(top ==  MS-1){
     86                              printf("栈空间太小,需增加MS的值!
    ");
     87                              exit(1);
     88                          }
     89                          if(p == NULL){
     90                              printf("p值不能为空,退出程序!
    ");
     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("二叉树广义表字符串有错!
    ");
    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("广义表字符串出错!
    ");
    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('
    ');                   //先序遍历
    11      Inorder(p)   putchar('
    ');                                  //中序遍历 
    12      Postorder(p)  putchar('
    ');                    //后序遍历
    13      Levelorder(p)  putchar('
    ');                    //按层遍历
    14      InorderN(p)  putchar('
    ');                             //中序非递归遍历
    15      printf("%d
    ",BTreeDepth(p));                           //求二叉树深度
    16      k = FindBTree(p, 'I'); if(k!=NULL) printf("%c
    ", *k);   //查找二叉树
    17      PrintBTree(p);                                       //输出二叉树
    18      p = ClearBTree(p);                                   //清空二叉树
    19      n1 = BTreeEmpty(P);  printf("%d
    ", n1);             //判断树是否为空
    20      
    21      }
  • 相关阅读:
    VUE第一个项目怎么读懂
    Excel催化剂开源第33波-Quick Bible For PPT插件项目全代码开源
    [iOS基础控件
    awk支持多个记录分隔符的写法
    关于awk中NR、FNR、NF、$NF、FS、OFS的说明
    测试开发CICD——Docker——docker安装nginx
    测试开发CICD——Docker——docker安装python3.5
    测试开发CICD——Docker——docker安装tomcat
    测试开发CICD——Docker——docker安装redis
    测试开发CICD——Docker——docker安装mysql
  • 原文地址:https://www.cnblogs.com/WALLACE-S-BOOK/p/9903086.html
Copyright © 2011-2022 走看看