C语言链表实例

// 原文地址 http://www.cnblogs.com/renyuan/archive/2013/05/21/3091506.html  
/*在原文的基础上面做了以下补充，现在可以实现全部功能了*/
  1 #include<stdio.h>
  2 #include<stdlib.h>
  3 #include<string.h>
  4 
  5 typedef int elemType;//定义存入的数据的类型可以是int char 
  6 
  7 typedef struct NODE{ //定义链表的结构类型
  8     elemType element;
  9     struct NODE *next;
 10 }Node;
 11 
 12 /************************************************************************/
 13 /*             以下是关于线性表链接存储（单链表）操作的19种算法        */
 14 
 15 /* 1.初始化线性表，即置单链表的表头指针为空 */
 16 /* 2.创建线性表，此函数输入负数终止读取数据*/
 17 /* 3.打印链表，链表的遍历*/
 18 /* 4.清除线性表L中的所有元素，即释放单链表L中所有的结点，使之成为一个空表 */
 19 /* 5.返回单链表的长度 */
 20 /* 6.检查单链表是否为空，若为空则返回１，否则返回０ */
 21 /* 7.返回单链表中第pos个结点中的元素，若pos超出范围，则停止程序运行 */
 22 /* 8.从单链表中查找具有给定值x的第一个元素，若查找成功则返回该结点data域的存储地址，否则返回NULL */
 23 /* 9.把单链表中第pos个结点的值修改为x的值，若修改成功返回１，否则返回０ */
 24 /* 10.向单链表的表头插入一个元素 */
 25 /* 11.向单链表的末尾添加一个元素 */
 26 /* 12.向单链表中第pos个结点位置插入元素为x的结点，若插入成功返回１，否则返回０ */
 27 /* 13.向有序单链表中插入元素x结点，使得插入后仍然有序 */
 28 /* 14.从单链表中删除表头结点，并把该结点的值返回，若删除失败则停止程序运行 */
 29 /* 15.从单链表中删除表尾结点并返回它的值，若删除失败则停止程序运行 */
 30 /* 16.从单链表中删除第pos个结点并返回它的值，若删除失败则停止程序运行 */
 31 /* 17.从单链表中删除值为x的第一个结点，若删除成功则返回1,否则返回0 */
 32 /* 18.交换2个元素的位置 */
 33 /* 19.将线性表进行冒排序 */
 34 
 35 
 36 
 37 /*注意检查分配到的动态内存是否为空*/
 38 
 39 
 40 
 41 
 42 /* 1.初始化线性表，即置单链表的表头指针为空 */
 43 void initList(Node **pNode)
 44 {
 45     *pNode=NULL;
 46     printf("initList函数执行，初始化成功\n");
 47 }
 48 
 49 /* 2.创建线性表，此函数输入负数终止读取数据*/
 50 Node *creatList(Node *pHead)
 51 {
 52     Node *p1,*p2;
 53     p1=p2=(Node *)malloc(sizeof(Node));
 54     if(p1 == NULL || p2 ==NULL)
 55     {
 56         printf("内存分配失败\n");    
 57         exit(0);
 58     }
 59     memset(p1,0,sizeof(Node));
 60     
 61     scanf("%d",&p1->element);
 62     p1->next=NULL;
 63     
 64     while(p1->element >0)  //输入的值大于0则继续，否则停止
 65     {
 66         if(pHead == NULL)//空表，接入表头
 67         {
 68             pHead=p1;
 69         }
 70         else 
 71         {
 72             p2->next=p1;
 73         }
 74     
 75         p2=p1;
 76         p1=(Node *)malloc(sizeof(Node));
 77     
 78         if(p1==NULL||p2==NULL)
 79         {
 80             printf("内存分配失败\n");
 81             exit(0);
 82         }
 83         memset(p1,0,sizeof(Node));
 84         scanf("%d",&p1->element);
 85         p1->next=NULL;
 86     }
 87     printf("CreatList函数执行，链表创建成功\n");
 88     return pHead;    
 89 }
 90 
 91 /* 3.打印链表，链表的遍历*/
 92 void printList(Node *pHead)
 93 {
 94     if(NULL==pHead)
 95     {
 96         printf("PrintList函数执行，链表为空\n");
 97     }
 98     else
 99     {
100         while(NULL!=pHead)
101         {
102             printf("%d\n",pHead->element);
103             pHead=pHead->next;
104         }
105     }
106 
107 }
108 
109 
110 /* 4.清除线性表L中的所有元素，即释放单链表L中所有的结点，使之成为一个空表 */
111 void clearList(Node *pHead)
112 {
113     Node *pNext;
114     
115     if(pHead==NULL)
116     {
117         printf("clearList函数执行，链表为空\n");
118         return;
119     }
120     while(pHead->next!=NULL)
121     {
122         pNext=pHead->next;
123         free(pHead);
124         pHead=pNext;
125     }
126     printf("clearList函数执行，链表已经清除！\n");
127 
128 }
129 
130 /* 5.返回链表的长度*/
131 int sizeList(Node *pHead)
132 {
133     int size=0;
134     
135     while(pHead!=NULL)
136     {
137         size++;
138         pHead=pHead->next;
139     }
140     printf("sizelist函数执行，链表长度为%d\n",size);
141     return size;
142 }
143 
144 /* 6.检查单链表是否为空，若为空则返回１，否则返回０ */
145 int isEmptyList(Node *pHead)
146 {
147     if(pHead==NULL)
148     {
149         printf("isEmptylist函数执行，链表为空！\n");
150         return 1;
151     }
152 
153     else 
154         printf("isEmptylist函数执行，链表非空！\n");
155         return 0;
156 
157 }
158 
159 /* 7.返回链表中第post节点的数据，若post超出范围，则停止程序运行*/
160 int getElement(Node *pHead,int pos)
161 {
162     int i=0;
163     if(pos<1)
164     {
165         printf("getElement函数执行，pos值非法！");
166         return 0;
167     }
168     if(pHead==NULL)
169     {
170         printf("getElement函数执行，链表为空！");
171     }
172 
173     while (pHead!=NULL)
174     {
175         ++i;
176         if(i==pos)
177         {
178             break;
179         }
180         pHead=pHead->next;
181     }    
182     if(i<pos)
183     {
184         printf("getElement函数执行，pos值超出链表长度\n");
185         return 0;        
186     }
187     printf("getElement函数执行，位置%d中的元素为%d\n",pos,pHead->element);
188     
189     return 1;
190 }
191 
192 //8.从单一链表中查找具有给定值x的第一个元素，若查找成功后，返回该节点data域的存储位置，否则返回NULL
193 elemType *getElemAddr(Node *pHead,elemType x)
194 {
195     if(NULL==pHead)
196     {    
197         printf("getEleAddr函数执行，链表为空");
198         return NULL;    
199     }
200     if(x<0)
201     {
202         printf("getEleAddr函数执行，给定值x不合法\n");
203         return NULL;
204     }
205     while((pHead->element!=x)&&(NULL!=pHead->next))//判断链表是否为空，并且是否存在所查找的元素
206     {
207         pHead=pHead->next;
208     }    
209     if(pHead->element!=x)
210     {
211         printf("getElemAddr函数执行，在链表中没有找到x值\n");
212         return NULL;
213     }
214     else
215     {
216         printf("getElemAddr函数执行，元素%d的地址为0x%x\n",x,&(pHead->element));
217     }
218     return &(pHead->element);
219 
220 }    
221 
222 
223 /*9.修改链表中第pos个点X的值，如果修改成功，则返回1,否则返回0*/
224 int modifyElem(Node *pNode,int pos,elemType x)
225 {
226     Node *pHead;
227     pHead=pNode;
228     int i=0;
229     if(NULL==pHead)
230     {
231         printf("modifyElem函数执行，链表为空\n");
232         return 0;
233     }
234     
235     if(pos<1)
236     {
237         printf("modifyElem函数执行，pos值非法\n");
238         return 0;
239     }
240     
241     while(pHead!= NULL)
242     {
243         ++i;
244         if(i==pos)
245         {
246             break;
247         }
248         pHead=pHead->next;
249     }
250     
251     if(i<pos)
252     {
253         printf("modifyElem函数执行，pos值超出链表长度\n");
254         return 0;
255     }
256     pNode=pHead;
257     pNode->element=x;
258     printf("modifyElem函数执行,修改第%d点的元素为%d\n",pos,x);
259 
260     return 1;
261 
262 }
263 
264 /* 10.向单链表的表头插入一个元素 */
265 int insertHeadList(Node **pNode,elemType insertElem)
266 {
267     Node *pInsert;
268     pInsert=(Node *)malloc(sizeof(Node));
269     if(pInsert==NULL)  exit(1);
270     memset(pInsert,0,sizeof(Node));
271     pInsert->element=insertElem;
272     pInsert->next=*pNode;
273     *pNode=pInsert;
274     printf("insertHeadList函数执行，向表头插入元素%d成功\n",insertElem);
275     return 1;
276 }
277 
278 /* 11.向单链表的末尾添加一个元素 */
279 int insertLastList(Node *pNode,elemType insertElem)
280 {
281     Node *pInsert;    
282     Node *pHead;
283     Node *pTmp;
284 
285     pHead=pNode;
286     pTmp=pHead;
287     pInsert=(Node *)malloc(sizeof(Node));
288     if(pInsert==NULL)  exit(1);
289     memset(pInsert,0,sizeof(Node));
290     pInsert->element=insertElem;
291     pInsert->next=NULL;
292     while(pHead->next!=NULL)
293     {
294         pHead=pHead->next;
295     }
296     pHead->next=pInsert;      
297     printf("insertLastList函数执行，向表尾插入元素%d成功!\n",insertElem);
298     return     1;
299 }
300 
301 /* 12.向单链表中第pos个结点位置插入元素为x的结点，若插入成功返回１，否则返回０*/ 
302 int isAddPos(Node *pNode,int pos,elemType x)
303 {
304     Node *pHead;
305     pHead=pNode;
306     Node *pTmp;
307     int i=0;
308     
309     if(NULL==pHead)
310     {
311         printf("AddPos函数执行，链表为空\n");
312         return 0;
313     }
314     
315     if(pos<1)
316     {
317         printf("AddPos函数执行，pos值非法\n");
318         return 0;
319     }
320     
321     while(pHead!=NULL)
322     {
323         ++i;
324         if(i==pos)
325         break;
326         pHead=pHead->next;
327     }
328     
329     if(i<pos)
330     {
331         printf("AddPos函数执行，pos值超出链表长度\n");
332         return 0;
333     }
334     
335     pTmp=(Node *)malloc(sizeof(Node));
336     if(pTmp==NULL)  exit(1);
337     memset(pTmp,0,sizeof(Node));
338     pTmp->next=pHead->next;
339     pHead->next=pTmp;
340     pTmp->element=x;
341 
342     printf("AddPos函数执行成功，向节点%d后插入数值%d\n",pos,x);
343     return 1;
344 }
345 
346 /* 13.向有序单链表中插入元素x结点，使得插入后仍然有序 */
347 int OrrderList(Node *pNode,elemType x)
348 {
349 //注意如果此数值要排到行尾要修改本代码
350     Node *pHead;
351         pHead=pNode;
352         Node *pTmp;
353         
354         if(NULL==pHead)
355         {
356                 printf("OrrderList函数执行，链表为空\n");
357                 return 0;
358         }
359 
360         if(x<1)
361         {
362                 printf("OrrderList函数执行，x值非法\n");
363                 return 0;
364         }
365 
366         while(pHead!=NULL)
367         {
368                 if((pHead->element)>=x)
369                 break;
370                 pHead=pHead->next;
371         }
372     
373     
374     if(pHead==NULL)   
375     {
376         printf("OrrderList函数查找完毕，该函数中没有该值\n");
377         return 0;
378     }    
379         
380 
381     pTmp=(Node *)malloc(sizeof(Node));
382     if(pTmp==NULL)  exit(1);       
383     memset(pTmp,0,sizeof(Node));
384         pTmp->next=pHead->next;
385         pHead->next=pTmp;
386         pTmp->element=x;
387     
388     printf("OrrderList函数成功插入数值%d\n",x);
389     return 1;
390 }
391 
392 /*14.从单链表中删除表头结点，并把该结点的值返回，若删除失败则停止程序运行*/
393 int DelHeadList(Node **pList)
394 {
395     Node *pHead;
396     pHead=*pList;
397     if(pHead!=NULL)
398     printf("DelHeadList函数执行,函数首元素为%d删除成功\n",pHead->element);
399     else 
400     {
401         printf("DelHeadList函数执行,链表为空!");
402         return 0;
403     }
404     *pList=pHead->next;
405     return 1;
406 }
407 
408 /* 15.从单链表中删除表尾结点并返回它的值，若删除失败则停止程序运行 */
409 int DelLastList(Node *pNode)
410 {    
411     Node *pHead;
412     Node *pTmp;
413 
414     pHead=pNode;
415     while(pHead->next!=NULL)
416     {
417         pTmp=pHead;
418         pHead=pHead->next;
419     }
420     printf("链表尾删除元素%d成功!\n",pHead->element);
421     free(pHead);
422     pTmp->next=NULL;
423     return     1;
424 }
425 
426 /* 16.从单链表中删除第pos个结点并返回它的值，若删除失败则停止程序运行 */
427 int DelPos(Node *pNode,int pos)
428 {
429     Node *pHead;
430     pHead=pNode;
431     Node *pTmp;
432 
433     int i=0;
434     
435     if(NULL==pHead)
436     {
437         printf("DelPos函数执行，链表为空\n");
438         return 0;
439     }
440     
441     if(pos<1)
442     {
443         printf("DelPos函数执行，pos值非法\n");
444         return 0;
445     }
446     
447     while(pHead!=NULL)
448     {
449         ++i;
450         if(i==pos)
451         break;
452         pTmp=pHead;
453         pHead=pHead->next;
454     }
455     
456     if(i<pos)
457     {
458         printf("DelPos函数执行，pos值超出链表长度\n");
459         return 0;
460     }
461         printf("DelPos函数执行成功，节点%d删除数值%d\n",pos,pHead->element);
462     pTmp->next=pHead->next;
463     free(pHead);    
464     return 1;
465 }
466 
467 /* 17.从单链表中删除值为x的第一个结点，若删除成功则返回1,否则返回0 */
468 int Delx(Node **pNode,int x)
469 {
470     Node *pHead;
471     Node *pTmp;
472     pHead=*pNode;
473     int i=0;
474             
475     if(NULL==pHead)
476     {    
477         printf("Delx函数执行，链表为空");
478         return 0;    
479     }
480     if(x<0)
481     {
482         printf("Delx函数执行，给定值x不合法\n");
483         return 0;
484     }
485     while((pHead->element!=x)&&(NULL!=pHead->next))//判断链表是否为空，并且是否存在所查找的元素
486     {
487         ++i;
488         pTmp=pHead;    
489         pHead=pHead->next;
490     }    
491     if(pHead->element!=x)
492     {
493         printf("Delx函数执行，在链表中没有找到x值\n");
494         return 0;
495     }
496     if((i==0)&&(NULL!=pHead->next))
497     {
498         printf("Delx函数执行，在链表首部找到此元素,此元素已经被删除\n");
499         *pNode=pHead->next;
500         free(pHead);
501         return 1;
502     }
503     printf("Delx函数执行，首个为%d元素被删除\n",x);
504     pTmp->next=pHead->next;
505     free(pHead);
506     return 1;
507 }
508 
509 /* 18.交换2个元素的位置 */
510 int exchange2pos(Node *pNode,int pos1,int pos2)
511 {
512     Node *pHead;
513     int *pTmp;
514     int *pInsert;
515     int a;
516     int i=0;
517     
518     if(pos1<1||pos2<1)
519         {
520                 printf("DelPos函数执行，pos值非法\n");
521                 return 0;
522         }
523     
524     pHead=pNode;
525         while(pHead!=NULL)
526         {
527                 ++i;
528                 if(i==pos1)
529                 break;
530                 pHead=pHead->next;
531         }
532 
533         if(i<pos1)
534         {
535                 printf("DelPos函数执行，pos1值超出链表长度\n");
536                 return 0;
537         }
538 
539     pTmp=&(pHead->element);
540     i=0;
541     pHead=pNode;
542         while(pHead!=NULL)
543         {
544                 ++i;
545                 if(i==pos2)
546                 break;
547                 pHead=pHead->next;
548         }
549 
550         if(i<pos2)
551         {
552                 printf("DelPos函数执行，pos2值超出链表长度\n");
553                 return 0;
554         }
555 
556     pInsert=&(pHead->element);
557     a=*pTmp;
558     *pTmp=*pInsert;
559     *pInsert=a;
560     
561     printf("DelPos函数执行,交换第%d个和第%d个pos点的值\n",pos1,pos2);
562         return 1;
563 }
564 
565 int swap(int *p1,int *p2)
566 {
567     int a;
568     if(*p1>*p2)
569     {
570         a=*p1;
571         *p1=*p2;
572         *p2=a;
573     }
574     return 0;
575 }
576 
577 /* 19.将线性表进行冒泡排序 */
578 int Arrange(Node *pNode)
579 {
580     Node *pHead;
581         pHead=pNode;
582 
583     int a=0,i,j;
584 
585         if(NULL==pHead)
586         {
587                  printf("Arrange函数执行，链表为空\n");
588                  return 0;
589         }
590         
591     while(pHead!=NULL)
592     {
593         ++a;
594             pHead=pHead->next;
595         }
596      
597     pHead=pNode;
598     for(i=0;i<a-1;i++)
599     {
600         for(j=1;j<a-i;j++)
601         {
602             swap(&(pHead->element),&(pHead->next->element));
603             pHead=pHead->next;
604         }
605         pHead=pNode;
606     }
607     printf("Arrange函数执行，链表排序完毕!\n");
608     return 0;
609 }
610 
611 int main()
612 {
613     Node *pList=NULL;
614     int length=0;
615     
616     elemType posElem;
617     
618     initList(&pList);
619     printList(pList);
620     
621     pList=creatList(pList);
622     printList(pList);
623     
624     sizeList(pList);
625     printList(pList);
626 
627     isEmptyList(pList);
628     
629 
630         posElem=getElement(pList,3);
631     printList(pList);
632     
633     getElemAddr(pList,5);
634 
635     modifyElem(pList,4,1);
636     printList(pList);
637     
638     insertHeadList(&pList,5);
639     printList(pList);
640 
641     insertLastList(pList,10);
642     printList(pList);
643 
644     isAddPos(pList,4,5);
645     printList(pList);
646     
647     OrrderList(pList,6);
648     printList(pList);
649     
650     DelHeadList(&pList);    
651     printList(pList);
652     
653     DelLastList(pList);
654     printList(pList);
655     
656     DelPos(pList,5);
657     printList(pList);
658     
659     Delx(&pList,5);
660     printList(pList);
661     
662     exchange2pos(pList,2,5);
663     printList(pList);
664     
665     Arrange(pList);    
666     printList(pList);
667     
668     clearList(pList);
669     return 0;
670 }