zoukankan      html  css  js  c++  java

  • 最基本的二叉树

    来源：http://blog.csdn.net/hopeyouknow/article/details/6740616?reload

    一个最基本的二叉树~~

    头文件BiTree.h

    [cpp] view plaincopy
    1. typedef int Item;  
    2. typedef struct node  
    3. {  
    4.     struct node * lchild;  
    5.     struct node * rchild;  
    6.     Item data;  
    7. }BiTNode,*BiTree;  
    8.   
    9. /*构造一棵新的二叉树*/  
    10. BiTree InitBiTree(BiTNode *root);  
    11.   
    12. /*生成节点*/  
    13. BiTNode *MakeNode(Item item,BiTNode *lchild,BiTNode *rchild);  
    14. /*释放节点*/  
    15. void FreeNode(BiTNode *pnode);  
    16.   
    17. /*清空一棵二叉树*/  
    18. void ClearBiTree(BiTree tree);  
    19.   
    20. /*销毁一棵二叉树*/  
    21. void DestroyBiTree(BiTree tree);  
    22.   
    23. /*判定是否为空*/  
    24. IsEmpty(BiTree tree);  
    25.   
    26. /*返回树的深度*/  
    27. GetDepth(BiTree tree);  
    28.   
    29. /*返回根*/  
    30. BiTree GetRoot(BiTree tree);  
    31.   
    32. /*返回节点值*/  
    33. Item GetItem(BiTNode *pnode);  
    34.   
    35. /*设置节点值*/  
    36. void SetItem(BiTNode *pnode,Item item);  
    37.   
    38. /*设置左子树*/  
    39. BiTree SetLChild(BiTree parent,BiTree lchild);  
    40.   
    41. /*设置右子树*/  
    42. BiTree SetRChild(BiTree parent,BiTree rchild);  
    43.   
    44. /*返回左子树*/  
    45. BiTree GetLChild(BiTree tree);  
    46.   
    47. /*返回右子树*/  
    48. BiTree GetRChild(BiTree tree);  
    49.   
    50. /*插入新子树*/  
    51. BiTree InsertChild(BiTree parent,int lr,BiTree child);  
    52.   
    53. /*删除子树*/  
    54. void DeleteChild(BiTree parent,int lr);  
    55.   
    56. /*先序遍历二叉树*/  
    57. PreOrderTraverse(BiTree tree,void(*visit)());  
    58.   
    59. /*中序遍历二叉树*/  
    60. InOrderTraverse(BiTree tree,void(*visit)());  
    61.   
    62. /*后序遍历二叉树*/  
    63. PostOrderTraverse(BiTree tree,void(*visit)());  


    实现文件BiTree.c如下

    [cpp] view plaincopy
    1. #include"BiTree.h"  
    2. #include<malloc.h>  
    3. #include<stdlib.h>  
    4.   
    5. /*构造一棵新的二叉树*/  
    6. BiTree InitBiTree(BiTNode *root)  
    7. {  
    8.     BiTree tree = root;  
    9.     return tree;  
    10. }  
    11.   
    12. /*生成节点*/  
    13. BiTNode *MakeNode(Item item,BiTNode *lchild,BiTNode *rchild)  
    14. {  
    15.     BiTNode * pnode = (BiTNode *)malloc(sizeof(BiTNode));  
    16.     if(pnode)  
    17.     {  
    18.         pnode->data = item;  
    19.         pnode->lchild = lchild;  
    20.         pnode->rchild = rchild;  
    21.     }  
    22.     return pnode;     
    23. }  
    24.   
    25. /*释放节点*/  
    26. void FreeNode(BiTNode *pnode)  
    27. {  
    28.     if(pnode!=NULL)  
    29.         free(pnode);  
    30. }  
    31.   
    32. /*清空一棵二叉树*/  
    33. void ClearBiTree(BiTree tree)  
    34. {  
    35.     BiTNode * pnode = tree;  
    36.     if(pnode->lchild!=NULL)  
    37.         ClearBiTree(pnode->lchild);  
    38.   
    39.     if(pnode->rchild!=NULL)  
    40.         ClearBiTree(pnode->rchild);  
    41.   
    42.     FreeNode(pnode);  
    43. }  
    44.   
    45. /*销毁一棵二叉树*/  
    46. void DestroyBiTree(BiTree tree)  
    47. {  
    48.     if(tree)  
    49.         ClearBiTree(tree);    
    50. }  
    51.   
    52. /*判定是否为空*/  
    53. IsEmpty(BiTree tree)  
    54. {  
    55.     if(tree==NULL)  
    56.         return 0;  
    57.     else  
    58.         return 1;  
    59. }  
    60.   
    61. /*返回树的深度*/  
    62. int GetDepth(BiTree tree)  
    63. {  
    64.     int cd,ld,rd;  
    65.     cd = ld = rd = 0;  
    66.     if(tree)  
    67.     {  
    68.         ld = GetDepth(tree->lchild);  
    69.         rd = GetDepth(tree->rchild);  
    70.         cd = (ld > rd ? ld : rd);  
    71.         return cd+1;  
    72.     }  
    73.     else  
    74.         return 0;  
    75. }  
    76.   
    77. /*返回根*/  
    78. BiTree GetRoot(BiTree tree)  
    79. {  
    80.     return tree;  
    81. }  
    82.   
    83. /*返回节点值*/  
    84. Item GetItem(BiTNode *pnode)  
    85. {  
    86.     return pnode->data;  
    87. }  
    88.   
    89. /*设置节点值*/  
    90. void SetItem(BiTNode *pnode,Item item)  
    91. {  
    92.     pnode->data = item;  
    93. }  
    94.   
    95. /*设置左子树*/  
    96. BiTree SetLChild(BiTree parent,BiTree lchild)  
    97. {  
    98.     parent->lchild = lchild;  
    99.     return lchild;  
    100. }  
    101.   
    102. /*设置右子树*/  
    103. BiTree SetRChild(BiTree parent,BiTree rchild)  
    104. {  
    105.     parent->rchild = rchild;  
    106.     return rchild;  
    107. }  
    108.   
    109. /*返回左子树*/  
    110. BiTree GetLChild(BiTree tree)  
    111. {  
    112.     if(tree)  
    113.         return tree->lchild;  
    114.     return NULL;  
    115. }  
    116.   
    117. /*返回右子树*/  
    118. BiTree GetRChild(BiTree tree)  
    119. {  
    120.     if(tree)  
    121.         return tree->rchild;  
    122.     return NULL;  
    123. }  
    124.   
    125. /*插入新子树*/  
    126. BiTree InsertChild(BiTree parent,int lr,BiTree child)  
    127. {  
    128.     if(parent)  
    129.     {  
    130.         if( lr == 0 && parent->lchild == NULL)  
    131.         {  
    132.             parent->lchild = child;  
    133.             return child;  
    134.         }     
    135.         if( lr == 1 && parent->rchild == NULL)  
    136.         {  
    137.             parent->rchild = child;  
    138.             return child;  
    139.         }     
    140.     }  
    141.     return NULL;      
    142. }  
    143.   
    144. /*删除子树*/  
    145. void DeleteChild(BiTree parent,int lr)  
    146. {  
    147.     if(parent)  
    148.     {  
    149.         if( lr == 0 && parent->lchild != NULL)  
    150.         {  
    151.             parent->lchild = NULL;  
    152.             FreeNode(parent->lchild);  
    153.         }     
    154.         if( lr == 1 && parent->rchild != NULL)  
    155.         {  
    156.             parent->rchild = NULL;  
    157.             FreeNode(parent->rchild);  
    158.         }     
    159.     }  
    160. }  
    161.   
    162. /*先序遍历二叉树*/  
    163. PreOrderTraverse(BiTree tree,void(*visit)())  
    164. {  
    165.     BiTNode * pnode = tree;  
    166.     if(pnode)  
    167.     {  
    168.         visit(pnode->data);  
    169.         PreOrderTraverse(pnode->lchild,visit);  
    170.         PreOrderTraverse(pnode->rchild,visit);  
    171.     }  
    172. }  
    173.   
    174. /*中序遍历二叉树*/  
    175. InOrderTraverse(BiTree tree,void(*visit)())  
    176. {  
    177.     BiTNode * pnode = tree;  
    178.     if(pnode)  
    179.     {  
    180.         InOrderTraverse(pnode->lchild,visit);  
    181.         visit(pnode->data);  
    182.         InOrderTraverse(pnode->rchild,visit);  
    183.     }  
    184. }  
    185.   
    186. /*后序遍历二叉树*/  
    187. PostOrderTraverse(BiTree tree,void(*visit)())  
    188. {  
    189.     BiTNode * pnode = tree;  
    190.     if(pnode)  
    191.     {  
    192.         PostOrderTraverse(pnode->lchild,visit);        
    193.         PostOrderTraverse(pnode->rchild,visit);  
    194.         visit(pnode->data);  
    195.     }  
    196. }  


    简单测试程序如下

    [cpp] view plaincopy
      1. #include"BiTree.h"  
      2. #include<stdio.h>  
      3. void print(Item item)  
      4. {  
      5.     printf("%d ",item);  
      6. }  
      7. main()  
      8. {     
      9.     BiTNode * n1 = MakeNode(10,NULL,NULL);  
      10.     BiTNode * n2 = MakeNode(20,NULL,NULL);  
      11.     BiTNode * n3 = MakeNode(30,n1,n2);  
      12.     BiTNode * n4 = MakeNode(40,NULL,NULL);  
      13.     BiTNode * n5 = MakeNode(50,NULL,NULL);  
      14.     BiTNode * n6 = MakeNode(60,n4,n5);  
      15.     BiTNode * n7 = MakeNode(70,NULL,NULL);  
      16.   
      17.     BiTree tree = InitBiTree(n7);  
      18.     SetLChild(tree,n3);  
      19.     SetRChild(tree,n6);  
      20.   
      21.     printf("树的深度为：%d",GetDepth(tree));  
      22.       
      23.     printf(" 先序遍历如下：");  
      24.     PreOrderTraverse(tree,print);  
      25.   
      26.     printf(" 中序遍历如下：");  
      27.     InOrderTraverse(tree,print);  
      28.   
      29.     printf(" 后序遍历如下：");  
      30.     PostOrderTraverse(tree,print);  
      31.   
      32.     DeleteChild(tree,1);  
      33.     printf(" 后序遍历如下：");  
      34.     PostOrderTraverse(tree,print);  
      35.   
      36.     DestroyBiTree(tree);  
      37.     if(IsEmpty(tree))  
      38.      printf(" 二叉树为空，销毁完毕 ");  
      39. } 
  • 相关阅读:
    微擎二次开发
    linux
    自动自发与强制要求的差别
    金老师的经典著作《一个普通IT人的十年回顾》
    离开了公司，你还有什么
    [转]想靠写程序赚更多钱，写到两眼通红，写得比别人都又快又好好几倍，结果又能如何？
    挨踢人生路--记我的10年18家工作经历 续 .转
    论优越感
    当程序员的那些狗日日子-----转载
    C#语法杂谈
  • 原文地址：https://www.cnblogs.com/heyonggang/p/3272629.html
Copyright © 2011-2022 走看看