1. #include <stdio.h>  
  2. #include <malloc.h>  
  3.  
  4. typedef char ElemType;  
  5.  
  6. typedef struct LNode  
  7. {  
  8.  ElemType data;  
  9.  struct LNode * next;  
  10. }LinkList;  
  11.  
  12.  
  13. LinkList *InitiaList()  
  14. {  
  15.  LinkList *L;  
  16.  L = (LinkList *)malloc(sizeof(LinkList));  
  17.  L->next = NULL;  
  18.  return L;  
  19. }  
  20.  
  21.  
  22. void DestoryList1(LinkList * L)  
  23. {  
  24.  LinkList *p = L,*q = p->next;  
  25.  while(q != NULL)  
  26.  {  
  27.   free(p);  
  28.   p = q;  
  29.   q = p->next;  
  30.  }  
  31.  free(p);  
  32. }  
  33.  
  34.  
  35. void SetNull(LinkList * L)  
  36. {  
  37.  L->next = NULL;  
  38. }  
  39.  
  40.  
  41. int ListEmpty1(LinkList * L)  
  42. {  
  43.  return (L->next == NULL);  
  44. }  
  45.  
  46.  
  47. int ListLength1(LinkList * L)  
  48. {  
  49.  LinkList *P = L;  
  50.  int i = 0;  
  51.  while(P->next != NULL)  
  52.  {  
  53.   i ++;  
  54.   P = P->next;  
  55.  }  
  56.  return i;  
  57. }  
  58.  
  59.  
  60. ElemType GetElem1(LinkList * L,int i)  
  61. {  
  62.  int j = 0;  
  63.  LinkList *p = L;  
  64.  ElemType e;  
  65.  while (j < i && p != NULL)  
  66.  {  
  67.   j ++;  
  68.   p = p->next;  
  69.  }  
  70.  if (p == NULL)  
  71.  {  
  72.   return ('F');  
  73.  }  
  74.  else 
  75.  {  
  76.   e = p->data;  
  77.   return e;  
  78.  }  
  79. }  
  80.  
  81.  
  82. int LocateElem1(LinkList * L,ElemType e)  
  83. {  
  84.  LinkList *p = L->next;  
  85.  int n = 1;  
  86.  while(p != NULL && p->data != e)  
  87.  {  
  88.   p = p->next;  
  89.   n ++;  
  90.  }  
  91.  if (p == NULL)  
  92.  {  
  93.   return 0;  
  94.  }  
  95.  else 
  96.  {  
  97.   return n;  
  98.  }  
  99. }  
  100.  
  101.  
  102. ElemType PriorElem1(LinkList * L,ElemType cur_e)  
  103. {  
  104.  LinkList *p = L->next;  
  105.  ElemType pre_e;  
  106.  if (p->data == cur_e)  
  107.  {  
  108.   return ('F');  
  109.  }  
  110.  else 
  111.  {  
  112.   while (p->next->data != cur_e)  
  113.   {  
  114.    p = p->next;  
  115.   }  
  116.   pre_e = p->data;  
  117.   return pre_e;  
  118.  }  
  119. }  
  120.  
  121.  
  122. ElemType NextElem1(LinkList * L,ElemType cur_e)  
  123. {  
  124.  LinkList *p = L->next,*q;  
  125.  ElemType next_e;  
  126.  if (p == NULL)  
  127.  {  
  128.   return ('F');  
  129.  }  
  130.  else 
  131.  {  
  132.   while(p->data != cur_e)  
  133.    p = p->next;  
  134.   q = p->next;  
  135.   if (q != NULL)  
  136.   {  
  137.    next_e = q ->data;  
  138.    return next_e;  
  139.   }  
  140.   else 
  141.   {  
  142.    return ('F');  
  143.   }  
  144.  }  
  145. }  
  146.  
  147.  
  148. int ListInsert1(LinkList * L,int i,ElemType e)  
  149. {  
  150.  int j = 0;  
  151.  LinkList *p = L,*s;  
  152.  while(j < i-1 && p != NULL)  
  153.  {  
  154.   j ++;  
  155.   p = p->next;  
  156.  }  
  157.  if (p == NULL || j > i-1)  
  158.  {  
  159.   return 0;  
  160.  }  
  161.  else 
  162.  {  
  163.   s = (LinkList *)malloc(sizeof(LinkList));  
  164.   s->data = e;  
  165.   s->next = p->next;  
  166.   p->next = s;  
  167.   return 1;  
  168.  }  
  169. }  
  170.  
  171.  
  172. ElemType ListDelete1(LinkList * L,int i)  
  173. {  
  174.  int j = 0;  
  175.  LinkList * p = L,*q;  
  176.  ElemType e;  
  177.  while(j < i-1 && p != NULL)  
  178.  {  
  179.   j ++;  
  180.   p = p->next;  
  181.  }  
  182.  if (p == NULL || j > i-1)  
  183.  {  
  184.   return ('F');  
  185.  }  
  186.  else 
  187.  {  
  188.   q = p->next;  
  189.   if(q == NULL)  
  190.    return ('F');  
  191.   e = q->data;  
  192.   p->next = q->next;  
  193.   free(q);  
  194.   return e;  
  195.  }  
  196. }  
  197.  
  198.  
  199. void ListTraverse1(LinkList * L)  
  200. {  
  201.  LinkList *p = L->next;  
  202.  while(p != NULL)  
  203.  {  
  204.   printf(" %c",p->data);  
  205.   p = p->next;  
  206.  }  
  207.  printf("\n");  
  208. }  
  209.  
  210.  
  211. void main()  
  212. {  
  213.  ElemType e;  
  214.  LinkList * L = NULL;  
  215.  L = InitiaList();  
  216.  ListInsert1(L,1,'i');  
  217.  ListInsert1(L,2,'l');  
  218.  ListInsert1(L,3,'o');  
  219.  ListInsert1(L,4,'v');  
  220.  ListInsert1(L,5,'e');  
  221.  ListInsert1(L,6,'y');  
  222.  ListInsert1(L,7,'o');  
  223.  ListInsert1(L,8,'u');  
  224.  ListTraverse1(L);  
  225.  printf("\n");  
  226.  printf("单链表L的长度：%d\n",ListLength1(L));  
  227.  printf("元素y的位置：%d\n",LocateElem1(L,'y'));  
  228.  printf("单链表L为:%s\n",(ListEmpty1(L)?"空":"非空"));  
  229.  e = GetElem1(L,4);  
  230.  printf("单链表L的第4个元素:%c\n",e);  
  231.  e = PriorElem1(L,'y');  
  232.  printf("元素y的前驱元素:%c\n",e);  
  233.  e = NextElem1(L,'y');  
  234.  printf("元素y的后驱元素:%c\n",e);  
  235.  ListInsert1(L,5,'h');  
  236.  ListTraverse1(L);  
  237.  e = ListDelete1(L,5);  
  238.  ListTraverse1(L);  
  239.  SetNull(L);  
  240.  printf("单链表L为:%s\n",(ListEmpty1(L)?"空":"非空"));  
  241.  DestoryList1(L);  
  242.  printf("成功释放单链表\n");   
  243. }  
  244.