第九周 二叉树算法库

来源:互联网 发布:官居一品 知乎 编辑:程序博客网 时间:2024/06/05 06:38
  1. 烟台大学计算机学院  
  2.   
  3. 文件名称:xiangmu.cpp  
  4.   
  5. 作者:李浩南 
  6.   
  7.   
  8. 问题描述:定义二叉树的链式存储结构,实现其基本运算,并完成测试 
  9.   
  10. 输入描述:无 
  11.   
  12. 输出描述:输出二叉树,查找后结果,左右孩子 
  13.   
  14. */   
  15.   
  16.   
  17.   
  18. //btree.h:  
  19.   
  20.   
  21.   
  22. #include <stdio.h>  
  23.   
  24. typedef char ElemType;  
  25.   
  26. typedef struct node  
  27. {  
  28.     ElemType data;  
  29.   
  30.     struct node *lchild;  
  31.   
  32.     struct node *rchild;  
  33. }BTNode;  
  34.   
  35. void CreateBTNode(BTNode *&b,char *str);        //由str串创建二叉链  
  36. BTNode *FindNode(BTNode *b,ElemType x);     //返回data域为x的节点指针  
  37. BTNode *LchildNode(BTNode *p);      //返回*p节点的左孩子节点指针  
  38. BTNode *RchildNode(BTNode *p);      //返回*p节点的右孩子节点指针  
  39. int BTNodeDepth(BTNode *b);     //求二叉树b的深度  
  40. void DispBTNode(BTNode *b);     //以括号表示法输出二叉树  
  41. void DestroyBTNode(BTNode *&b);     //销毁二叉树  
  42.   
  43.   
  44. //btree.cpp:  
  45.   
  46. #include <stdio.h>  
  47. #include <malloc.h>  
  48. #include "btree.h"  
  49. #define MaxSize 100  
  50.   
  51. void CreateBTNode(BTNode *&b,char *str)  
  52. {  
  53.     BTNode *St[MaxSize],*p;  
  54.   
  55.     int top=-1,k,j=0;  
  56.   
  57.     char ch;  
  58.   
  59.     b=NULL;  //建立的二叉树初始时为空  
  60.   
  61.   
  62.     ch=str[j];  
  63.   
  64.     while(ch!='\0'//扫描字符串  
  65.     {  
  66.         switch(ch)//遇到字母。左右括号,逗号的操作  
  67.         {  
  68.             case '(':top++;  
  69.             St[top]=p;  
  70.             k=1;  
  71.             break;  
  72.             case ')':  
  73.                 top--;  
  74.                 break;  
  75.                 case ',':  
  76.                     k=2;  
  77.                 break;  
  78.                 default:p=(BTNode*)malloc(sizeof(BTNode));  
  79.                 p->data=ch;  
  80.                 p->lchild=p->rchild=NULL;  
  81.                 if(b==NULL)  
  82.                 {  
  83.                     b=p;  
  84.                 }  
  85.                 else  
  86.                     {  
  87.                         switch(k)  
  88.                         {  
  89.                             case 1:  
  90.                             St[top]->lchild=p;  
  91.                             break;  
  92.                             case 2:  
  93.                                 St[top]->rchild=p;  
  94.                                 break;  
  95.                         }  
  96.                     }  
  97.          }  
  98.          j++;  
  99.          ch=str[j];  
  100.   
  101.     }  
  102. }  
  103.   
  104. void DestroyBTNode(BTNode *&b)  
  105. {  
  106.     if(b!=NULL)  
  107.     {  
  108.         DestroyBTNode(b->lchild);//销毁左子树  
  109.         DestroyBTNode(b->rchild);//销毁右子树  
  110.         free(b);//销毁根结点  
  111.   
  112.     }  
  113. }  
  114.   
  115. BTNode *FindNode(BTNode *b,ElemType x)  
  116. {  
  117.     BTNode *p;  
  118.     if(b==NULL)  
  119.     {  
  120.         return NULL;  
  121.     }  
  122.     else if(b->data==x)  
  123.         return b;  
  124.     else  
  125.         {  
  126.             p=FindNode(b->lchild,x);//递归查找该结点  
  127.             if(p!=NULL)  
  128.             {  
  129.                 return p;  
  130.             }  
  131.             else  
  132.                 return FindNode(b->rchild,x);  
  133.         }  
  134. }  
  135.   
  136. BTNode *LchildNode(BTNode *p)//求左子树  
  137. {  
  138.     return p->lchild;  
  139. }  
  140. BTNode *RchildNode(BTNode *p)//求右子树  
  141. {  
  142.     return p->rchild;  
  143. }  
  144.   
  145. int BTNodeDepth(BTNode *b)  
  146. {  
  147.     int lchildh;  
  148.   
  149.     int rchildh;  
  150.   
  151.     if(b==NULL)  
  152.         return 0;//空树  
  153.     else  
  154.     {  
  155.         lchildh=BTNodeDepth(b->lchild);//递归求根结点左子树  
  156.         rchildh=BTNodeDepth(b->rchild);//递归求根结点右子树  
  157.         {  
  158.             if(lchildh>rchildh)  
  159.             {  
  160.                 return lchildh+1;  
  161.             }  
  162.             else  
  163.                 {  
  164.                     return rchildh+1;  
  165.                 }  
  166.         }  
  167.   
  168.   
  169.     }  
  170. }  
  171.   
  172. void DispBTNode(BTNode *b)//以括号表示法输出二叉树  
  173. {  
  174.     if(b!=NULL)  
  175.     {  
  176.         printf("%c",b->data);  
  177.         if(b->lchild!=NULL || b->rchild!=NULL)  
  178.         {  
  179.             printf("(");  
  180.             DispBTNode(b->lchild);  
  181.             if(b->rchild!=NULL)  
  182.             {  
  183.                 printf(",");  
  184.                 DispBTNode(b->rchild);  
  185.             }  
  186.             printf(")");  
  187.   
  188.         }  
  189.     }  
  190. }  
  191.   
  192.   
  193. //main:  
  194.   
  195.   
  196. #include <stdio.h>  
  197. #include "btree.h"  
  198.   
  199. int main()  
  200. {  
  201.     BTNode *p,*lp,*rp;  
  202.     BTNode *p1;  
  203.     CreateBTNode(p,"A(B(D,E(H(J,K(L,M(,N))))),C(F,G(,I)))");//二叉树建立  
  204.     DispBTNode(p);  
  205.     if(FindNode(p,'H')!=NULL)  
  206.   
  207.     {  
  208.         p1=FindNode(p,'H');  
  209.   
  210.   if (p1!=NULL)  
  211.     {  
  212.         lp=LchildNode(p1);  
  213.         if (lp!=NULL)  
  214.             printf("\n左孩子为%c\n",lp->data);  
  215.         else  
  216.             printf("\n无左孩子\n");  
  217.         rp=RchildNode(p1);  
  218.         if (rp!=NULL)  
  219.             printf("右孩子为%c\n",rp->data);  
  220.         else  
  221.             printf("无右孩子\n");  
  222.     }  
  223.     else  
  224.         printf(" 未找到\n");  
  225.   
  226.   
  227.     }  
  228.     printf("%d\n",BTNodeDepth(p));  
  229.     printf("销毁树");  
  230.   
  231.     DestroyBTNode(p);  
  232.   
  233.     return 0;  
  234. }  
原创粉丝点击