单链表增加头结点

方便插入、删除操作

注意与单链表的代码区别，尤其是细节部分

2.    #include <stdio.h>  
3.    #include <stdlib.h>  
4.    //定义带头结点的单链表   
5.    typedef int ElemType;  
6.    typedef struct node  
7.    {  
8.        ElemType elem;  
9.        struct node *next;  
10.    }Node;  
11.    typedef struct headerList  
12.    {  
13.        Node *header;  
14.        int n;  
15.    }HeaderList;  
16.    //初始化操作  
17.    int Init(headerList *L)  
18.    {  
19.        L->header = (Node*)malloc(sizeof(Node));  
20.        if(!L->header)       //表示必须有头结点   
21.            return 0;  
22.        L->header->next = NULL;  
23.        L->n = 0;  
24.        return 1;  
25.    }   
26.    //查找操作  
27.    //查找链表L中下标为i的元素，并赋值给x   
28.    int Find(headerList L,int i,ElemType *x)   
29.    {  
30.        int j;  
31.        Node *p;  
32.        if(i<0 || i> L.n-1)  
33.            return 0;  
34.        if(!L.n)  
35.            return 0;  
36.        p = L.header;  
37.        for(j=0;j<i;j++)  
38.            p = p->next;  
39.        *x = p->elem;  
40.        return 1;         
41.    }  
42.    //插入操作  
43.    //在下标i之前插入元素x   
44.    int Insert(headerList *L,int i,ElemType x)  
45.    {  
46.        Node *p,*q;  //p指向i位置，q指向插入元素x  
47.        int j;  
48.        if (i<-1 || i>L->n-1)  
49.            return 0;  
50.        p = L->header;  
51.        for(j=0;j<=i;j++)  
52.            p = p->next;  
53.        q = (Node*)malloc(sizeof(Node));  
54.        q->elem = x;  
55.        q->next = p->next;  
56.        p->next = q;  
57.        L->n++;  
58.        return 1;  
59.    }  
60.    //在下标i的元素x   
61.    int Delete(headerList *L,int i)  
62.    {  
63.        Node *p,*q;  //p指向i位置，q指向删除元素x  
64.        int j;  
65.        if (i<0 || i>L->n-1)  
66.            return 0;  
67.        if(!L->n)  
68.            return 0;  
69.        p = L->header;  
70.        for(j=0;j<i;j++)  
71.            p = p->next;  
72.        q = p->next;  
73.        p->next = q->next;  
74.        free(q);   
75.        L->n++;  
76.        return 1;  
77.    }  
78.    //输出操作    
79.    int Output(headerList *L)  
80.    {  
81.        Node *p;  
82.        p = L->header->next;  //注意头结点没有元素   
83.        if(!L->n)  
84.            return 0;  
85.        while(p)  
86.        {  
87.            printf("%d ",p->elem);  
88.            p = p->next;  
89.        }  
90.        printf("\n");  
91.        return 1;     
92.    }   
93.    void Destory(headerList *L)  
94.    {  
95.        Node *p;  
96.        while(L->header)  
97.        {  
98.            p = L->header->next;  
99.            free(L->header);  
100.            L->header = p;  
101.        }  
102.    }   
103.    int main(void)  
104.    {  
105.        int i,x;  
106.        Node *p;  
107.        headerList list;  
108.        Init(&list);  
109.        for(i=0;i<10;i++)  
110.            Insert(&list,i-1,i*2);  
111.        printf("执行插入操作之后的结果：\n");  
112.        Output(&list);  
113.        Find(list,2,&x);  
114.        printf("执行查找操作之后的结果：x=%d\n",x);   
115.        Delete(&list,2);  
116.        printf("执行插入操作之后的结果：\n");  
117.        Output(&list);  
118.        Destory(&list);  
119.        return 0;  
120.    }