1.  
  2. /单链表//  
  3. #include <stdio.h>  
  4. #include <malloc.h>  
  5. #include <stdlib.h>  
  6. #include <time.h>  
  7.  
  8.  
  9. #define OK    1  
  10. #define ERROR 0  
  11. #define TRUE  1  
  12. #define FALSE 0  
  13. typedef int Status;  
  14. typedef int ElemType;  //ElemType类型根据实际情况而定，这里假定为int  
  15.  
  16. /* 线性表的单链表存储结构*/ 
  17. typedef struct Node  
  18. {  
  19.     ElemType data;   //存储数据元素  
  20.     struct Node* next; //存储指向后继的指针  
  21. }Node, *LinkList;  
  22.  
  23.  
  24. //单链表的读取操作,核心思想工作指针后移  
  25. Status GetElem(LinkList L, int i, ElemType* e)  
  26. {  
  27.     int j;  
  28.     LinkList p;   //声明一个指向节点的P指针  
  29.     p = L->next;  //p指向链表L中的第一个结点  
  30.     j = 1;        //j为计数器  
  31.  
  32.     while (p && j<i)  
  33.     {  
  34.         p = p->next;  //核心思想是工作指针后移  
  35.         j++;  
  36.     }  
  37.  
  38.     if (p || j>i)  
  39.     {  
  40.         return ERROR;   //第i个元素不存在  
  41.     }  
  42.  
  43.     *e = p->data;  
  44.     return OK;  
  45. }  
  46.  
  47.  
  48. //单链表的插入操作  
  49. Status ListInsert(LinkList* L, int i, ElemType e)  
  50. {  
  51.  
  52.     int j = 1; //计速器  
  53.     LinkList p = *L; //工作指针,初始化指向头结点  
  54.     LinkList s = NULL;   
  55.  
  56.     while(p && j<i)  //让工作指针p指向i-1个结点  
  57.     {  
  58.         p = p->next;  
  59.         j++;  
  60.     }  
  61.  
  62.     if (!p || j>i)  
  63.     {  
  64.         return ERROR;  
  65.     }  
  66.  
  67.     s = (LinkList)malloc(sizeof(Node)); //生成新的结点  
  68.     s->data = e;  
  69.     s->next = p->next;   //将p的后继结点赋值给s的后继  
  70.     p->next = s;         //将s赋值给p的后继  
  71.  
  72.     return OK;  
  73. }  
  74.  
  75. //单链表的删除操作  
  76. Status ListDelete(LinkList* L, int i, ElemType *e)  
  77. {  
  78.     int j = 1; //计速器  
  79.     LinkList p = *L; //工作指针,初始化指向头结点  
  80.     LinkList q = NULL;   
  81.       
  82.     while(p->next && j<i)  //让工作指针p指向i-1个结点  
  83.     {  
  84.         p = p->next;  
  85.         j++;  
  86.     }  
  87.       
  88.     if (!(p->next) || j>i)  
  89.     {  
  90.         return ERROR;  
  91.     }  
  92.     q = p->next;  
  93.     p->next = q->next;  
  94.  
  95.     *e = q->data;  
  96.     free(q);  
  97.     return OK;  
  98.  
  99. }  
  100.  
  101. //单链表的整表创建,头插法，始终让新结点在第一个位置  
  102. void CreateListHead(LinkList* L, int n)  
  103. {  
  104.     LinkList p;  
  105.     int i;  
  106.     srand(time(0));     //初始化随机种子  
  107.     *L = (LinkList)malloc(sizeof(Node)); //头结点  
  108.     (*L)->next = NULL;   //先建立一个带头结点的单链表  
  109.  
  110.     for (i=0; i<n; i++)  
  111.     {  
  112.         p = (LinkList)malloc(sizeof(Node));  
  113.         p->data = rand()%100+1; //随机产生100以内的数字  
  114.         p->next =(*L)->next;  
  115.         (*L)->next = p;  
  116.     }  
  117.  
  118. }  
  119.  
  120. //单链表的整表创建尾插法，始终让新结点在最后位置  
  121. void CreateListHead(LinkList* L, int n)  
  122. {  
  123.     LinkList p, r;  
  124.     int i;  
  125.     srand(time(0));     //初始化随机种子  
  126.     *L = (LinkList)malloc(sizeof(Node)); //头结点  
  127.     (*L)->next = NULL;   //先建立一个带头结点的单链表  
  128.     r = *L;              //r为指向尾部的结点  
  129.       
  130.     for (i=0; i<n; i++)  
  131.     {  
  132.         p = (LinkList)malloc(sizeof(Node));  
  133.         p->data = rand()%100+1; //随机产生100以内的数字  
  134.         p->next = NULL;  
  135.         r = p;              //r要指向最后一个元素  
  136.     }  
  137.     r->next = p;            //表示当前链表结束  
  138.       
  139. }  
  140.  
  141.  
  142. //单链表的整表删除  
  143. Status ClearList(LinkList* L)  
  144. {  
  145.     LinkList p, q;  
  146.     p = (*L)->next; //p指向第一个结点  
  147.  
  148.     while(p!=NULL)  
  149.     {  
  150.         q = p->next;  
  151.         free(p);  
  152.         p = q;  
  153.     }  
  154.  
  155.     (*L)->next = NULL; //头结点指针域为NULL  
  156.  
  157.     return OK;  
  158. }  
  159.  
  160.  
  161.