[已解决]求大佬们救救孩子，数据结构作业就要交了，很急很急

小菜鸡溜溜达

实验内容
1、按层序次序输入二叉树中结点的值(字符型或整型)，构造顺序存储的二叉树T；
2、判断二叉树是否为空，输出二叉树的深度和根结点的值；
3、分别按层次序列、先序、中序、后序方法遍历二叉树，并打印。


看到帖子的大佬们：
有时间的话能不能瞅一眼孩子的代码，实在是不会了都看一早上了
没时间的话可不可以直接写个答案（不要写太复杂的，我看不懂TAT），我慢慢观摩

1. #include<stdio.h>
   
2. #include<conio.h>
   
3. #include<malloc.h>
   
4. #include<stdlib.h>
   
5. 
   
6. // 定义二叉树二叉列表存储结构 结构体 BiTNode
   
7. typedef struct BiTNode{   
   
8.         char data;
   
9.         struct BiTNode *lchild, *rchild;
   
10. }BiTNode,*BiTree;
    
11. 
    
12. //创建一棵二叉树
    
13. //按书上写的敲下来的，看不太懂
    
14. BiTree CreateBiTree(BiTree T){
    
15.         char ch;
    
16.         printf("请输入节点：\n");
    
17.         scanf("%c",&ch);
    
18.         fflush(stdin);    //清空输入缓冲区
    
19.         if (ch=='\0')
    
20.         {
    
21.                 T=NULL;
    
22.         }
    
23.         else{
    
24.                 if(!(BiTree*)malloc(sizeof(BiTNode))) exit(0);
    
25.                 //判断内存分配空间是否成功,给T指针分配连续的BiTree类型所占字节数的内存空间
    
26.                 T->data = ch;
    
27.                 T->lchild = CreateBiTree(T->lchild);
    
28.                 T->rchild = CreateBiTree(T->rchild);
    
29.         }
    
30.         return(T);
    
31. }
    
32. //如何实现输出根结点？
    
33. //遍历二叉树
    
34. void level(BiTNode *T)
    
35. {
    
36.         //层次遍历二叉树
    
37.         int front, rear,maxSize;
    
38.         BiTNode *que[maxSize];
    
39.         front = rear = 0;
    
40.         BiTNode *p;
    
41.         rear = (rear+1) % maxSize;
    
42.         que[rear] = T;
    
43.         while(front != rear)
    
44.         {
    
45.                 p = que[front];
    
46.                 //Visit(p); //我该怎么定义这个visit函数呢？
    
47.                 if(p->lchild != NULL)
    
48.                 {
    
49.                         rear = (rear+1) % maxSize;
    
50.                         que[rear] = p->lchild;
    
51.                 }
    
52.                 if(p->rchild != NULL)
    
53.                 {
    
54.                         rear = (rear+1) % maxSize;
    
55.                         que[rear] = p->rchild;
    
56.                 }
    
57.         }
    
58. 
    
59. }
    
60. 
    
61. //遍历二叉树
    
62. //void LevelOrder(BiTree *T) {
    
63. //        //层次序列遍历
    
64. //    InitQueue(Q); //初始化一个队列Q
    
65. //    BiTree *p; //p用来跟踪队头元素
    
66. //    EnQueue(Q,T); //根节点入队
    
67. //    while(!IsEmpty(Q)) {
    
68. //        DeQueue(Q,p);
    
69. //        visit(p);
    
70. //        if(p->lchild!=null) {
    
71. //            EnQueue(Q,p->lchild);
    
72. //        }
    
73. //        if(p->rchild!=null) {
    
74. //            EnQueue(Q,p->rchild);
    
75. //        }
    
76. //        }
    
77. //}
    
78. 
    
79. //先序遍历
    
80. void  PreOrderTraverse(BiTree T){
    
81.         if(T){
    
82.                 printf("%c",T->data);                        // 打印 当前节点存储的数据
    
83.                 PreOrderTraverse(T->lchild);        // 遍历左节点树
    
84.                 PreOrderTraverse(T->rchild);        // 遍历右节点树
    
85.         }
    
86. }
    
87. 
    
88. //中序遍历
    
89. void InOrderTraverse(BiTree T){
    
90.         if(T){
    
91.                 InOrderTraverse(T->lchild);
    
92.                 printf("%c",T->data);
    
93.                 InOrderTraverse(T->rchild);
    
94.         }
    
95. }
    
96. 
    
97. //后序遍历
    
98. void PostOrderTraverse(BiTree T){
    
99.         if(T){
    
100.                 PostOrderTraverse(T->lchild);
     
101.                 PostOrderTraverse(T->rchild);
     
102.                 printf("%c",T->data);
     
103.         }
     
104. }
     
105. 
     
106. //返回二叉树的深度
     
107. int GetDepth(BiTree T)
     
108. {
     
109.         int l,r,c;
     
110.         l=r=c=0;
     
111.         if(T) {
     
112.                 l=GetDepth(T->lchild);
     
113.                 r=GetDepth(T->rchild);
     
114.                 c=(l>r?l:r);
     
115.                 return c+1;
     
116.         }
     
117.         else {
     
118.                 return 0;
     
119.         }
     
120. }
     
121. 
     
122. 
     
123. int main()
     
124. {
     
125.         BiTree T;
     
126.         T=CreateBiTree(T);
     
127.         //判断二叉树是否为空
     
128.         if(T)                // todo 这一行有问题
     
129.                 printf("二叉树不为空\n");
     
130.         else
     
131.                 printf("二叉树为空\n");
     
132.         printf("二叉树的深度是：\n");
     
133.         printf("%d\n",GetDepth(T));
     
134.         if(T)
     
135.                 printf("%c\n",T->data); //输出二叉树根结点的值  todo 但是不需要这个代码 下面会打印的
     
136.         printf("输出按层次序列遍历二叉树：\n");       
     
137.         level(T);
     
138.         printf("输出按先序遍历二叉树：\n");       
     
139.         PreOrderTraverse(T);
     
140.         printf("输出按中序遍历二叉树：\n");       
     
141.         InOrderTraverse(T);
     
142.         printf("输出按后序遍历二叉树：\n");       
     
143.         PostOrderTraverse(T);
     
144.         return 0;
     
145. }
     

复制代码

最佳答案

月排行榜 / 总排行榜

Gacy

2021-10-17 13:22:37

这是前中后序的，你自己看一下算法，自己加一个层次遍历 的进去就可以了

1. #include <stdio.h>
   
2. #include <stdlib.h>
   
3. /*二叉树链式存储的头文件*/
   
4. typedef char datatype;         /*结点属性值的类型*/
   
5. typedef struct node{           /*二叉树结点的类型*/
   
6.   datatype  data;
   
7.   struct node  *lchild,*rchild;
   
8. }bintnode,*bintree;
   
9. 
   
10. 
    
11. bintree createbintree()
    
12. {/*按照前序遍历的顺序建立一棵给定的二叉树*/
    
13. char ch;
    
14. bintree t;
    
15. if ((ch=getchar())=='#')
    
16.       t=NULL;
    
17. else {
    
18.           t=(bintnode *)malloc(sizeof(bintnode));
    
19.           t->data=ch;
    
20.           t->lchild=createbintree();
    
21.           t->rchild=createbintree();
    
22.        }
    
23.     return t;
    
24. }
    
25. 
    
26. 
    
27. void preorder(bintree t)
    
28.   { /*前序遍历二叉树的递归算法*/
    
29.     if (t) {
    
30.              printf("%c",t->data);       /*根左右*/
    
31.                          preorder(t->lchild);
    
32.                  preorder(t->rchild);
    
33.              }
    
34.      }
    
35. 
    
36. 
    
37. void inorder(bintree t)
    
38.   { /*中序遍历二叉树的递归算法*/
    
39.     if (t) {
    
40.                          inorder(t->lchild);    /*左根右*/
    
41.                          printf("%c",t->data);
    
42.                  inorder(t->rchild);
    
43.              }
    
44.      }
    
45. 
    
46. 
    
47. void postorder(bintree t)
    
48.   { /*后序遍历二叉树的递归算法*/
    
49.     if (t) {
    
50.              postorder(t->lchild);         /*左右根*/
    
51.                  postorder(t->rchild);
    
52.              printf("%c",t->data);
    
53.               }
    
54.      }
    
55. 
    
56. 
    
57. void main()
    
58.   { bintree root;    /*自定义*/
    
59.    
    
60.     printf("请输入二叉树的结点值：");  root=createbintree();   /*上面的输入二叉树的函数建二叉树*/
    
61.    
    
62.     printf("二叉树的前序遍历结果为：");  preorder(root);
    
63.    
    
64.     printf("\n二叉树的中序遍历结果为：");  inorder(root);
    
65.    
    
66.     printf("\n二叉树的后序遍历结果为：");  postorder(root);
    
67. }
    

复制代码

跳转到最佳答案楼层

Gacy

这种作业好像上学期我都做了那时候我也像你一样急啊哈哈

Gacy

这是前中后序的，你自己看一下算法，自己加一个层次遍历 的进去就可以了

1. #include <stdio.h>
   
2. #include <stdlib.h>
   
3. /*二叉树链式存储的头文件*/
   
4. typedef char datatype;         /*结点属性值的类型*/
   
5. typedef struct node{           /*二叉树结点的类型*/
   
6.   datatype  data;
   
7.   struct node  *lchild,*rchild;
   
8. }bintnode,*bintree;
   
9. 
   
10. 
    
11. bintree createbintree()
    
12. {/*按照前序遍历的顺序建立一棵给定的二叉树*/
    
13. char ch;
    
14. bintree t;
    
15. if ((ch=getchar())=='#')
    
16.       t=NULL;
    
17. else {
    
18.           t=(bintnode *)malloc(sizeof(bintnode));
    
19.           t->data=ch;
    
20.           t->lchild=createbintree();
    
21.           t->rchild=createbintree();
    
22.        }
    
23.     return t;
    
24. }
    
25. 
    
26. 
    
27. void preorder(bintree t)
    
28.   { /*前序遍历二叉树的递归算法*/
    
29.     if (t) {
    
30.              printf("%c",t->data);       /*根左右*/
    
31.                          preorder(t->lchild);
    
32.                  preorder(t->rchild);
    
33.              }
    
34.      }
    
35. 
    
36. 
    
37. void inorder(bintree t)
    
38.   { /*中序遍历二叉树的递归算法*/
    
39.     if (t) {
    
40.                          inorder(t->lchild);    /*左根右*/
    
41.                          printf("%c",t->data);
    
42.                  inorder(t->rchild);
    
43.              }
    
44.      }
    
45. 
    
46. 
    
47. void postorder(bintree t)
    
48.   { /*后序遍历二叉树的递归算法*/
    
49.     if (t) {
    
50.              postorder(t->lchild);         /*左右根*/
    
51.                  postorder(t->rchild);
    
52.              printf("%c",t->data);
    
53.               }
    
54.      }
    
55. 
    
56. 
    
57. void main()
    
58.   { bintree root;    /*自定义*/
    
59.    
    
60.     printf("请输入二叉树的结点值：");  root=createbintree();   /*上面的输入二叉树的函数建二叉树*/
    
61.    
    
62.     printf("二叉树的前序遍历结果为：");  preorder(root);
    
63.    
    
64.     printf("\n二叉树的中序遍历结果为：");  inorder(root);
    
65.    
    
66.     printf("\n二叉树的后序遍历结果为：");  postorder(root);
    
67. }
    

复制代码

Gacy

你加油 好像我没看到你代码抱歉

小菜鸡溜溜达

Gacy 发表于 2021-10-17 13:22
这是前中后序的，你自己看一下算法，自己加一个层次遍历 的进去就可以了

太太太感谢了，但我还想知道层次遍历以及输出根结点该怎么表示，书上没看到有相关代码

Gacy

要不我找找？？上学期的事了，不知道还有没有
基础的书上肯定有啊

小菜鸡溜溜达

Gacy 发表于 2021-10-17 15:13
要不我找找？？上学期的事了，不知道还有没有
基础的书上肯定有啊

好的，我确实翻了好多遍二叉树相关的页码，没有有前中后序的代码

Gacy

你看看对你有没有用

1. void levelorder(tree t)    /*树的层次遍历，t为指向树根结点的指针*/
   
2.     {  tree queue[100];        /*存放等待访问的结点队列*/
   
3.        int f,r,i;            /*f、r分别为队头、队尾指针*/
   
4.        tree p;
   
5.        f=0; r=1; queue[0]=t;
   
6.        while(f<r)      /*队列不为空*/
   
7.         {p=queue[f]; f++; printf("%c",p->data);  /*访问队头元素*/
   
8.          for(i=0;i<m;i++)   /*将刚被访问的元素的所有子女结点依次进队*/
   
9.            if(p->child[i])
   
10.             {queue[r]=p->child[i];  r++;}
    
11.          }
    
12.      }

复制代码

Gacy

小菜鸡溜溜达 发表于 2021-10-17 15:17
好的，我确实翻了好多遍二叉树相关的页码，没有有前中后序的代码

我怎么印象中书上是有的呢拜拜了我先看教资去了有空再来