[已解决]这个什么情况，看不出问题在哪里，这个错误提示

御坂19090

1. #include <stdio.h>
   
2. #include <stdlib.h>
   
3. 
   
4. typedef int ElemType;
   
5. 
   
6. typedef struct BiTNode {//二叉链表
   
7.         ElemType data;
   
8.         BiTree lchild;        //左指针
   
9.         BiTree rchild;        //右指针
   
10. } BiTNode, * BiTree;
    
11. 
    
12. /*
    
13. -二叉排序树：
    
14. -若它的左子树不为空, 则左子树上所有结点的值均小于它的根结构的值;
    
15. -若它的右子树不为空, 则右子树上所有结点的值大于它的根结构的值;
    
16. -它的左、右子树也分别为二叉排序树（递归）。
    
17. */
    
18. 
    
19. //递归查找二叉排序树T中是否存在key
    
20. //若查找成功，则指针p指向该数据元素结点，并返回1
    
21. //否则指针p指向查找路径上访问的最后一个结点，并返回0
    
22. //f指向T的双亲，初始值值为NULL
    
23. int Search_BinarySortTree(BiTree T, int key, BiTree f, BiTree *p) {
    
24.         if (!T) {        //查找不成功
    
25.                 *p = f;
    
26.                 return 0;
    
27.         }
    
28.         else if (key == T->data) {        //查找成功
    
29.                 *p = T;
    
30.                 return 1;
    
31.         }
    
32.         else if (key < T->data) {        //在左子树继续查找
    
33.                 return Search_BinarySortTree(T->lchild, key, T, p);
    
34.         }
    
35.         else {                                                //在右子树继续查找
    
36.                 return Search_BinarySortTree(T->rchild, key, T, p);
    
37.         }
    
38. }
    
39. 
    
40. //当二叉排序树T中不存在关键字等于key的数据元素时，插入key并返回1否则返回0
    
41. //如果T为NULL；要给T根节点，所以为BiTree *T
    
42. int Insert_BinarySortTree(BiTree *T, int key) {
    
43.         BiTree p, s;
    
44.        
    
45.         if (!Search_BinarySortTree(*T, key, NULL, &p)) {
    
46.                 s = (BiTree)malloc(sizeof(BiTNode));        //创建一个新的节点
    
47.                 s->data = key;
    
48.                 s->lchild = s->rchild = NULL;
    
49. 
    
50.                 if (!p) {        //说明没有根节点；树为空
    
51.                         *T = s;        //插入s为新的根结点
    
52.                 }
    
53.                 else if (key < p->data) {        //key小于它的的值
    
54.                         p->lchild = s;        //s作为左子树
    
55.                 }
    
56.                 else{        //key大于它的的值
    
57.                         p->rchild = s;        //s作为右子树
    
58.                 }
    
59.                 return 1;
    
60.         }
    
61.         else{
    
62.                 return 0;        //树中已有关键字相同的结点，不再插入
    
63. 
    
64.         }
    
65. }
    
66. 
    
67. //删除二叉排序树T中的key
    
68. int Delete_BinarySortTree(BiTree *T, int key) {
    
69.         BiTree p;
    
70. 
    
71.         if (Search_BinarySortTree(*T, key, NULL, &p)) {        //找到要删除的节点
    
72.                 return Delete(&p);
    
73.         }
    
74.         else {
    
75.                 return 0;        //树中找不到节点值为key
    
76.         }
    
77. }
    
78. 
    
79. //删除p节点；使用左子树的最大节点，或右子树的最小节点替换(p节点不为空)
    
80. int Delete(BiTree *p){
    
81.         BiTree q;        //存放要删除的节点；方便释放内存
    
82.         BiTree s;
    
83. 
    
84.         if ((*p)->rchild == NULL) {        //右指针为空
    
85.                 q = *p;
    
86.                 *p = (*p)->lchild;        //将左子树放在要删除的节点位置上
    
87.                 free(q);        //释放删除的节点
    
88.         }
    
89.         else if ((*p)->lchild == NULL) {        //左指针为空
    
90.                 q = *p;
    
91.                 *p = (*p)->rchild;        //右左子树放在要删除的节点位置上
    
92.                 free(q);        //释放删除的节点
    
93.         }
    
94.         else {        //2个都为空;这里使用直接前驱替换(还可以使用直接后驱)
    
95.                 q = *p;
    
96.                 s = (*p)->lchild;        //将左子树放在要删除的节点位置上
    
97.                 while (s->rchild) {        //找到最右边的子树
    
98.                         q = s;        //直接前驱的双亲
    
99.                         s = s->rchild;
    
100.                 }
     
101.                 //因为要保存链接，所以替换数据，删除被替换数据的节点
     
102.                 (*p)->data = s->data;        //使用直接前驱的值替换掉p节点的值
     
103.                 if (q != p) {        //s是q的右子树，
     
104.                         q->rchild = s->lchild;
     
105.                 }
     
106.                 else{        //q就是p节点，跳过s连接s->lchild
     
107.                         q->lchild = s->lchild;
     
108.                 }
     
109. 
     
110.                 free(s);
     
111.         }
     
112. 
     
113.         return 1;
     
114. }
     
115. 
     
116. 
     
117. int main() {
     
118.         return 0;
     
119. }

复制代码

最佳答案

月排行榜 / 总排行榜

FishAssembly

2023-2-26 03:20:23

第6到10行改成这样

1. typedef struct BiTNode {//二叉链表
   
2.     ElemType data;
   
3.     struct BiTNode *lchild;        //左指针
   
4.     struct BiTNode *rchild;        //右指针
   
5. } BiTNode, * BiTree;

复制代码

跳转到最佳答案楼层

jhq999

1. #include <stdio.h>
   
2. #include <stdlib.h>
   
3. 
   
4. typedef int ElemType;
   
5. 
   
6. typedef struct BiTNode {//二叉链表
   
7.         ElemType data;
   
8.         struct BiTNode* lchild;        //左指针
   
9.         struct BiTNode* rchild;        //右指针
   
10. } BiTNode, * BiTree;
    
11. 
    
12. /*
    
13. -二叉排序树：
    
14. -若它的左子树不为空, 则左子树上所有结点的值均小于它的根结构的值;
    
15. -若它的右子树不为空, 则右子树上所有结点的值大于它的根结构的值;
    
16. -它的左、右子树也分别为二叉排序树（递归）。
    
17. */
    
18. 
    
19. //递归查找二叉排序树T中是否存在key
    
20. //若查找成功，则指针p指向该数据元素结点，并返回1
    
21. //否则指针p指向查找路径上访问的最后一个结点，并返回0
    
22. //f指向T的双亲，初始值值为NULL
    
23. int Search_BinarySortTree(BiTree T, int key, BiTree f, BiTree *p) {
    
24.         if (!T) {        //查找不成功
    
25.                 *p = f;
    
26.                 return 0;
    
27.         }
    
28.         else if (key == T->data) {        //查找成功
    
29.                 *p = T;
    
30.                 return 1;
    
31.         }
    
32.         else if (key < T->data) {        //在左子树继续查找
    
33.                 return Search_BinarySortTree(T->lchild, key, T, p);
    
34.         }
    
35.         else {                                                //在右子树继续查找
    
36.                 return Search_BinarySortTree(T->rchild, key, T, p);
    
37.         }
    
38. }
    
39. 
    
40. //当二叉排序树T中不存在关键字等于key的数据元素时，插入key并返回1否则返回0
    
41. //如果T为NULL；要给T根节点，所以为BiTree *T
    
42. int Insert_BinarySortTree(BiTree *T, int key) {
    
43.         BiTree p, s;
    
44. 
    
45.         if (!Search_BinarySortTree(*T, key, NULL, &p)) {
    
46.                 s = (BiTree)malloc(sizeof(BiTNode));        //创建一个新的节点
    
47.                 s->data = key;
    
48.                 s->lchild = s->rchild = NULL;
    
49. 
    
50.                 if (!p) {        //说明没有根节点；树为空
    
51.                         *T = s;        //插入s为新的根结点
    
52.                 }
    
53.                 else if (key < p->data) {        //key小于它的的值
    
54.                         p->lchild = s;        //s作为左子树
    
55.                 }
    
56.                 else{        //key大于它的的值
    
57.                         p->rchild = s;        //s作为右子树
    
58.                 }
    
59.                 return 1;
    
60.         }
    
61.         else{
    
62.                 return 0;        //树中已有关键字相同的结点，不再插入
    
63. 
    
64.         }
    
65. }
    
66. //删除p节点；使用左子树的最大节点，或右子树的最小节点替换(p节点不为空)
    
67. int Delete(BiTree *p){///////////////////////////////////////////////////////////////////////////////把这个函数放前面调用它的函数前面
    
68.         BiTree q;        //存放要删除的节点；方便释放内存
    
69.         BiTree s;
    
70. 
    
71.         if ((*p)->rchild == NULL) {        //右指针为空
    
72.                 q = *p;
    
73.                 *p = (*p)->lchild;        //将左子树放在要删除的节点位置上
    
74.                 free(q);        //释放删除的节点
    
75.         }
    
76.         else if ((*p)->lchild == NULL) {        //左指针为空
    
77.                 q = *p;
    
78.                 *p = (*p)->rchild;        //右左子树放在要删除的节点位置上
    
79.                 free(q);        //释放删除的节点
    
80.         }
    
81.         else {        //2个都为空;这里使用直接前驱替换(还可以使用直接后驱)
    
82.                 q = *p;
    
83.                 s = (*p)->lchild;        //将左子树放在要删除的节点位置上
    
84.                 while (s->rchild) {        //找到最右边的子树
    
85.                         q = s;        //直接前驱的双亲
    
86.                         s = s->rchild;
    
87.                 }
    
88.                 //因为要保存链接，所以替换数据，删除被替换数据的节点
    
89.                 (*p)->data = s->data;        //使用直接前驱的值替换掉p节点的值
    
90.                 if (q != *p) {        //s是q的右子树，///////////////////////////////////////////////////////////
    
91.                         q->rchild = s->lchild;
    
92.                 }
    
93.                 else{        //q就是p节点，跳过s连接s->lchild
    
94.                         q->lchild = s->lchild;
    
95.                 }
    
96. 
    
97.                 free(s);
    
98.         }
    
99. 
    
100.         return 1;
     
101. }
     
102. //删除二叉排序树T中的key
     
103. int Delete_BinarySortTree(BiTree *T, int key) {
     
104.         BiTree p;
     
105. 
     
106.         if (Search_BinarySortTree(*T, key, NULL, &p)) {        //找到要删除的节点
     
107.                 return Delete(&p);
     
108.         }
     
109.         else {
     
110.                 return 0;        //树中找不到节点值为key
     
111.         }
     
112. }
     
113. 
     
114. 
     
115. 
     
116. 
     
117. int main() {
     
118.         return 0;
     
119. }
     

复制代码

jhq999

1. #include <stdio.h>
   
2. #include <stdlib.h>
   
3. 
   
4. typedef int ElemType;
   
5. 
   
6. typedef struct BiTNode {//二叉链表
   
7.         ElemType data;
   
8.         struct BiTNode* lchild;        //左指针
   
9.         struct BiTNode* rchild;        //右指针
   
10. } BiTNode, * BiTree;
    
11. 
    
12. /*
    
13. -二叉排序树：
    
14. -若它的左子树不为空, 则左子树上所有结点的值均小于它的根结构的值;
    
15. -若它的右子树不为空, 则右子树上所有结点的值大于它的根结构的值;
    
16. -它的左、右子树也分别为二叉排序树（递归）。
    
17. */
    
18. 
    
19. //递归查找二叉排序树T中是否存在key
    
20. //若查找成功，则指针p指向该数据元素结点，并返回1
    
21. //否则指针p指向查找路径上访问的最后一个结点，并返回0
    
22. //f指向T的双亲，初始值值为NULL
    
23. int Search_BinarySortTree(BiTree T, int key, BiTree f, BiTree *p) {
    
24.         if (!T) {        //查找不成功
    
25.                 *p = f;
    
26.                 return 0;
    
27.         }
    
28.         else if (key == T->data) {        //查找成功
    
29.                 *p = T;
    
30.                 return 1;
    
31.         }
    
32.         else if (key < T->data) {        //在左子树继续查找
    
33.                 return Search_BinarySortTree(T->lchild, key, T, p);
    
34.         }
    
35.         else {                                                //在右子树继续查找
    
36.                 return Search_BinarySortTree(T->rchild, key, T, p);
    
37.         }
    
38. }
    
39. 
    
40. //当二叉排序树T中不存在关键字等于key的数据元素时，插入key并返回1否则返回0
    
41. //如果T为NULL；要给T根节点，所以为BiTree *T
    
42. int Insert_BinarySortTree(BiTree *T, int key) {
    
43.         BiTree p, s;
    
44. 
    
45.         if (!Search_BinarySortTree(*T, key, NULL, &p)) {
    
46.                 s = (BiTree)malloc(sizeof(BiTNode));        //创建一个新的节点
    
47.                 s->data = key;
    
48.                 s->lchild = s->rchild = NULL;
    
49. 
    
50.                 if (!p) {        //说明没有根节点；树为空
    
51.                         *T = s;        //插入s为新的根结点
    
52.                 }
    
53.                 else if (key < p->data) {        //key小于它的的值
    
54.                         p->lchild = s;        //s作为左子树
    
55.                 }
    
56.                 else{        //key大于它的的值
    
57.                         p->rchild = s;        //s作为右子树
    
58.                 }
    
59.                 return 1;
    
60.         }
    
61.         else{
    
62.                 return 0;        //树中已有关键字相同的结点，不再插入
    
63. 
    
64.         }
    
65. }
    
66. //删除p节点；使用左子树的最大节点，或右子树的最小节点替换(p节点不为空)
    
67. int Delete(BiTree *p){///////////////////////////////////////////////////////////////////////////////把这个函数放前面调用它的函数前面
    
68.         BiTree q;        //存放要删除的节点；方便释放内存
    
69.         BiTree s;
    
70. 
    
71.         if ((*p)->rchild == NULL) {        //右指针为空
    
72.                 q = *p;
    
73.                 *p = (*p)->lchild;        //将左子树放在要删除的节点位置上
    
74.                 free(q);        //释放删除的节点
    
75.         }
    
76.         else if ((*p)->lchild == NULL) {        //左指针为空
    
77.                 q = *p;
    
78.                 *p = (*p)->rchild;        //右左子树放在要删除的节点位置上
    
79.                 free(q);        //释放删除的节点
    
80.         }
    
81.         else {        //2个都为空;这里使用直接前驱替换(还可以使用直接后驱)
    
82.                 q = *p;
    
83.                 s = (*p)->lchild;        //将左子树放在要删除的节点位置上
    
84.                 while (s->rchild) {        //找到最右边的子树
    
85.                         q = s;        //直接前驱的双亲
    
86.                         s = s->rchild;
    
87.                 }
    
88.                 //因为要保存链接，所以替换数据，删除被替换数据的节点
    
89.                 (*p)->data = s->data;        //使用直接前驱的值替换掉p节点的值
    
90.                 if (q != *p) {        //s是q的右子树，///////////////////////////////////////////////////////////
    
91.                         q->rchild = s->lchild;
    
92.                 }
    
93.                 else{        //q就是p节点，跳过s连接s->lchild
    
94.                         q->lchild = s->lchild;
    
95.                 }
    
96. 
    
97.                 free(s);
    
98.         }
    
99. 
    
100.         return 1;
     
101. }
     
102. //删除二叉排序树T中的key
     
103. int Delete_BinarySortTree(BiTree *T, int key) {
     
104.         BiTree p;
     
105. 
     
106.         if (Search_BinarySortTree(*T, key, NULL, &p)) {        //找到要删除的节点
     
107.                 return Delete(&p);
     
108.         }
     
109.         else {
     
110.                 return 0;        //树中找不到节点值为key
     
111.         }
     
112. }
     
113. 
     
114. 
     
115. 
     
116. 
     
117. int main() {
     
118.         return 0;
     
119. }
     

复制代码

FishAssembly

第6到10行改成这样

1. typedef struct BiTNode {//二叉链表
   
2.     ElemType data;
   
3.     struct BiTNode *lchild;        //左指针
   
4.     struct BiTNode *rchild;        //右指针
   
5. } BiTNode, * BiTree;

复制代码