递归二叉树深度不知哪里错了

Road_7

1. #include <stdio.h>
   
2. #include <stdlib.h>
   
3. 
   
4. int m , n;
   
5. typedef struct tree                 //define
   
6. {
   
7.         char zhi ;
   
8.         struct tree *Lchild;
   
9.         struct tree *Rchild;
   
10. }ErTree;
    
11. 
    
12. 
    
13. void CreateTree(ErTree *Tree)                        //build a Tree
    
14. {
    
15.         char a ;
    
16.         scanf("%c",&a);
    
17.         if( a == '#')
    
18.         Tree = NULL;
    
19.         else
    
20.         {
    
21.                 Tree = ( ErTree *)malloc(sizeof (ErTree));
    
22.                 Tree->zhi= a;
    
23.                 CreateTree(Tree->Lchild);
    
24.                 CreateTree(Tree->Rchild);
    
25.                
    
26.         }
    
27. 
    
28. }
    
29. 
    
30. 
    
31. int Deep( ErTree  *Tree)         //求深度
    
32. {               
    
33.        
    
34. 
    
35.         if (NULL == Tree)
    
36.                 return 0 ;
    
37.         else
    
38.         {
    
39.                 m = Deep(Tree->Lchild);
    
40.                 n = Deep(Tree->Rchild);
    
41.                
    
42.                 if( m >= n)
    
43.                          return        (m+1);
    
44.                  else  
    
45.                          return  (n+1) ;        
    
46.         }
    
47. }
    
48. 
    
49. 
    
50. 
    
51. int main()                       
    
52. {
    
53.         int c ;
    
54.          ErTree  Tree , *pTree;
    
55.         CreateTree(&Tree);
    
56.         c =Deep(&Tree);
    
57.         printf("%d",c);
    
58.        
    
59.         return 0 ;
    
60. }

复制代码

流行语

1. #include <stdio.h>
   
2. #include <stdlib.h>
   
3. 
   
4. int m, n;
   
5. typedef struct tree                 //define
   
6. {
   
7.         char zhi ;
   
8.         struct tree *Lchild;
   
9.         struct tree *Rchild;
   
10. }ErTree,*PErTree;
    
11. /************************************************************************/
    
12. /*
    
13. 初始化树根节点
    
14. */
    
15. /************************************************************************/
    
16. void InitTree(PErTree* root)
    
17. {
    
18.         *root = (PErTree)malloc(sizeof(struct tree));
    
19.         (*root)->zhi = 0;
    
20.         (*root)->Lchild = NULL;
    
21.         (*root)->Rchild = NULL;
    
22. }
    
23. 
    
24. /************************************************************************/
    
25. /*
    
26. build a Tree
    
27. */
    
28. /************************************************************************/
    
29. void CreateTree(ErTree** Tree)
    
30. {
    
31.          char a ;
    
32.          fflush(stdin);
    
33.          scanf("%c",&a);
    
34.          if(a == '#')
    
35.          {
    
36.                  return ;
    
37.          }
    
38.          else
    
39.          {
    
40.                  (*Tree)->Lchild = (ErTree *)malloc(sizeof (struct tree));
    
41.                  (*Tree)->Lchild->zhi = a;
    
42.                  (*Tree)->Lchild->Lchild = NULL;
    
43.                  (*Tree)->Lchild->Rchild = NULL;
    
44.                  CreateTree(&((*Tree)->Lchild));
    
45.                  
    
46.                  fflush(stdin);
    
47.                  scanf("%c",&a);
    
48.                  if( a == '#')
    
49.                  {
    
50.                          return ;
    
51.                  }
    
52.                  (*Tree)->Rchild = (ErTree *)malloc(sizeof (struct tree));
    
53.                  (*Tree)->Rchild->zhi = a;
    
54.                  (*Tree)->Rchild->Lchild = NULL;
    
55.                  (*Tree)->Rchild->Rchild = NULL;
    
56.                  CreateTree(&((*Tree)->Rchild));  
    
57.          }
    
58. }
    
59. 
    
60. 
    
61. int Deep( ErTree*Tree)         //求深度
    
62. {   
    
63.          int lChildDeep,rChildDeep;
    
64.          if (NULL == Tree)
    
65.                  return 0 ;
    
66.         else
    
67.         {
    
68.                 lChildDeep = Deep(Tree->Lchild);
    
69.                 rChildDeep = Deep(Tree->Rchild);
    
70.                 return (lChildDeep > rChildDeep)?(lChildDeep+1):(rChildDeep+1);
    
71.         }
    
72. }
    
73. 
    
74. 
    
75. 
    
76. int main()                        
    
77. {
    
78.          int c ;
    
79.          ErTree* Tree;
    
80.          InitTree(&Tree);
    
81.          CreateTree(&Tree);
    
82.          c =Deep(Tree);
    
83.          printf("%d",c);
    
84.          
    
85.          return 0 ;
    
86. }

复制代码

你看一下。

阔怀

厉害