我程序这样写，为什么会报错？56，57行

1. //
   
2. //  main.c
   
3. //  LinkList
   
4. //
   
5. //  Created by 池颉 on 14-9-21.
   
6. //  Copyright (c) 2014年 池颉. All rights reserved.
   
7. //
   
8. 
   
9. #include <stdio.h>
   
10. 
    
11. #define OK 1
    
12. #define ERROR 0
    
13. #define TRUE 1
    
14. #define FALSE 0
    
15. 
    
16. typedef int Status;
    
17. typedef int ElemType;
    
18. typedef struct Node{
    
19.     ElemType data;
    
20.     struct Node *next;
    
21. }Node;
    
22. 
    
23. typedef struct Node* LinkList;
    
24. 
    
25. /*输出所有元素*/
    
26. void PrintfAllElem(LinkList L){
    
27.     Node *p = L->next;
    
28.     int i = 0;
    
29.     while (p) {
    
30.         printf("index is %d,data is %d\n",i,p->data);
    
31.         p=p->next;
    
32.         ++i;
    
33.     }
    
34. }
    
35. 
    
36. /*单链表的读取*/
    
37. Status GetElem(LinkList L,int i,ElemType* e){
    
38.     Node* p = L->next;
    
39.     int j = 1;
    
40.    
    
41.     while (j<i && p) {
    
42.         p = p->next;
    
43.         j++;
    
44.     }
    
45.    
    
46.     if (!p || j > i)
    
47.         return ERROR;
    
48.     *e = p->data;
    
49.     return OK;
    
50. }
    
51. 
    
52. int main(int argc, const char * argv[]) {
    
53.    
    
54.     LinkList *l = malloc(sizeof(LinkList));
    
55.     Node *n = malloc(sizeof(Node));
    
56.     l->next = n;
    
57.     l->data = 0;
    
58.    
    
59.     Node *p = (Node*)l;
    
60.     p->next = n;
    
61.    
    
62.     PrintfAllElem(l);
    
63.    
    
64.     return 0;
    
65. }
    

复制代码

有没有可能是因为结构体没有初始化？

l的数据类型是LinkList的指针，不过你的LinkList已经typedef为Node的指针了，你在声明l的时候又用LinkList* ，我不知道是不是指针的指针，不过肯定的是l不是Node类型，他是没有data和next类型的。

好厉害，我现在还在装黑苹果呢。。。

housq 发表于 2014-9-23 10:54
l的数据类型是LinkList的指针，不过你的LinkList已经typedef为Node的指针了，你在声明l的时候又用LinkList* ...

你说的对，我改了一下，好了，这段程序是从书上弄下来的，我有个疑问，为什么作者会讲LinkList的类型设置为struct Node*类型，而不直接设置为Node类型呢？

1. 
   
2. #include <stdio.h>
   
3. #include <stdlib.h>
   
4. 
   
5. #define OK 1
   
6. #define ERROR 0
   
7. #define TRUE 1
   
8. #define FALSE 0
   
9. 
   
10. typedef int Status;
    
11. typedef int ElemType;
    
12. typedef struct Node{
    
13.     ElemType data;
    
14.     struct Node *next;
    
15. }Node;
    
16. 
    
17. typedef Node LinkList;
    
18. 
    
19. /*输出所有元素*/
    
20. void PrintfAllElem(LinkList* L){
    
21.     Node *p = (Node*)L;
    
22.     int i = 0;
    
23.     while (p) {
    
24.         printf("index is %d,data is %d\n",i,p->data);
    
25.         p=p->next;
    
26.         ++i;
    
27.     }
    
28. }
    
29. 
    
30. /*单链表的读取*/
    
31. Status GetElem(LinkList L,int i,ElemType* e){
    
32.     Node* p = L.next;
    
33.     int j = 1;
    
34.    
    
35.     while (j<i && p) {
    
36.         p = p->next;
    
37.         j++;
    
38.     }
    
39.    
    
40.     if (!p || j > i)
    
41.         return ERROR;
    
42.     *e = p->data;
    
43.     return OK;
    
44. }
    
45. 
    
46. /*插入节点*/
    
47. Status InsertElem(LinkList *list,int i,ElemType e)
    
48. {
    
49.     Node *p;
    
50.     int j;
    
51.    
    
52.     p = (Node*)list;
    
53.     j = 1;//从第一个位置开始数
    
54.    
    
55.     while (p && j<i) {
    
56.         j++;
    
57.         p = p->next;
    
58.     }
    
59.    
    
60.     if (!p || j>i) {
    
61.         return ERROR;
    
62.     }
    
63.    
    
64.     Node* new = malloc(sizeof(Node));
    
65.    
    
66.     new->next = p->next;
    
67.     new->data = e;
    
68.     p->next = new;
    
69.    
    
70.     return  OK;
    
71. }
    
72. /*删除节点*/
    
73. Status DelElem(LinkList *list,int i){
    
74.     Node *p,*q;
    
75.     int j;
    
76.     p = (Node*)list;
    
77.     j = 1;
    
78.    
    
79.     while (p && j<i) {
    
80.         p = p->next;
    
81.         j++;
    
82.     }
    
83.    
    
84.     if (!p || j>i) {
    
85.         return ERROR;
    
86.     }
    
87.    
    
88.     q = p->next;
    
89.     p->next = q->next;
    
90.     q->next = NULL;
    
91.     free(q);
    
92.    
    
93.     return OK;
    
94. }
    
95. 
    
96. int main(int argc, const char * argv[]) {
    
97.    
    
98.     LinkList* l = malloc(sizeof(LinkList));
    
99.     Node *n = malloc(sizeof(Node));
    
100. 
     
101.     l->next = n;
     
102.     l->data = 0;
     
103.    
     
104.     n->data = 1;
     
105.     n->next = NULL;
     
106.    
     
107.     InsertElem(l, 2, 3);
     
108.     InsertElem(l, 3, 4);
     
109.     InsertElem(l, 4, 5);
     
110.    
     
111.     PrintfAllElem(l);
     
112.    
     
113.     return 0;
     
114. }
     

复制代码

cjfire 发表于 2014-9-23 11:41
你说的对，我改了一下，好了，这段程序是从书上弄下来的，我有个疑问，为什么作者会讲LinkList的类型设置 ...

设为指针可以节约内存。无论结构体本身包含多少个成员，指针所占字节都只和机器字长有关。这样在函数调用传实参时就不必复制整个结构体

数据结构基础啊

fantacyleo 发表于 2014-9-23 12:46
设为指针可以节约内存。无论结构体本身包含多少个成员，指针所占字节都只和机器字长有关。这样在函数调用 ...

非常感谢。

cjfire 发表于 2014-9-23 11:41
你说的对，我改了一下，好了，这段程序是从书上弄下来的，我有个疑问，为什么作者会讲LinkList的类型设置 ...

指针更符合人们的习惯，也防止出错

housq 发表于 2014-9-23 17:56
指针更符合人们的习惯，也防止出错

多谢，我觉得fantacyleo说的挺好的。谢谢你们。