Linux C 学习 单向链表

最近从Linux C数据结构和算法学起，下面是一个单向链表的写法，代码如下：

[cpp]  view plain  copy

1. #include <stdio.h>  
2. #include <malloc.h>  
3.   
4.   
5. int n=0;  
6. typedef struct code  
7. {  
8.  int data;  
9.  struct code *next;  
10. }List;  
11.   
12.   
13. List *creatlink()  
14. {  
15.  List *head;  
16.  List *p1;  
17.  List *p2;  
18.  head=NULL;  
19.  p1=(List *)malloc(sizeof(List));  
20.  p2=(List *)malloc(sizeof(List));  
21.  printf("Please print the data you want:(end is 0)\n");  
22.  scanf("%d",&p1->data);  
23.  while(p1->data!=0)  
24.  {  
25.    n++;  
26.    if(n==1)  
27.     {  
28.      head=p1;  
29.     }  
30.     else  
31.      {  
32.        p2->next=p1;  
33.      }  
34.        p2=p1;  
35.        p1=(List *)malloc(sizeof(List));  
36.        scanf("%d",&p1->data);  
37.         // printf("\n%d\n",p1->data);  
38.    }  
39.    free(p1);  
40.    p2->next=NULL;  
41.    return(head);   
42. }  
43.   
44.   
45. void Print(List *head)  
46. {  
47.  List *p;  
48.  p=head;  
49.  if(head!=NULL)  
50.    do  
51.   {  
52.    printf("[%d]->",p->data);  
53.    p=p->next;  
54.   }  
55.   while(p!=NULL);  
56.   printf("\nover!\n");  
57.    
58. }  
59.   
60.   
61. int main()  
62. {  
63.  List *head;  
64.  head=creatlink();  
65.  Print(head);  
66.  return(0);  
67. }  

结果如下：

单向链表建立容易犯错误的是这一块：

  if(n==1)
    {
     head=p1;
    }
    else
     {
       p2->next=p1;
     }
       p2=p1;
       p1=(List *)malloc(sizeof(List));
       scanf("%d",&p1->data);
        // printf("\n%d\n",p1->data);
   }

先判定头指针，然后再重新为p1申请一片内存，来存放下一个链表里的内容

malloc()最容易出现的问题是内存泄露，所以一定要记得free();

下面有个例子：

兄弟问：" free(p);p=NUll;",为啥free(p)之后，还要置p=NULL呢？有必要么？

free(p)只是将p指向的空间释放掉了，但是p并不等于NULL;

code:

int main()
{
    int *p;
    p = (int *)malloc(sizeof(int) * 10);
    printf("before free:  p=%p\n",p);
    free(p);
    printf("after free: p = %p\n",p);
    printf("%d\n",p[0]);
    p=NULL;
    printf("%d\n",p[0]);
}

result:
before free:  p=0x8fa7008
after free: p = 0x8fa7008
0
段错误

也就是p虽然有值，但其指向的空间已经被释放掉了。如果在后续的code中再用到p，就会出现错误，而这种错误是不太明显的。如果显式的置为null的话，就可以使错误马上显现出来。从而避免了调试程序中种种诡异的麻烦。

结论：
           如果在程序中free(p)之后，p不会再用，则令p=NULL无所谓。
           如果在程序中free(p)之后，p还会用到，则令p=NULL,还原p为纯净的变量，便于以后差错。