单链表应用举例（单链表A和单链表B的元素都是非递减排列，利用单链表的基本运算，将它们合并成一个单链表C，要求C也是非递减序列）

#include <stdio.h>
#include <malloc.h>
#include <stdlib.h>
#include <string.h>
typedef int ElemType;
typedef struct Node
{
ElemType data;
struct Node *next;
}ListNode,*LinkList;//ListNode链表的结点类型,LinkList指向链表结点的指针类型

void InitList(LinkList *head);//单链表的初始化操作
int ListEmpty(LinkList head);//判断单链表是否为空
ListNode* Get(LinkList head,int i);//按序号查找操作
ListNode* LocateElem(LinkList head,ElemType e);//按内容查找操作
int LocatePos(LinkList head,ElemType e);//定位操作
int InsertList(LinkList head,int i,ElemType e);//插入操作
int DeleteList(LinkList head,int i,ElemType *e);//删除操作
int ListLength(LinkList head);//求表长操作
void DestroyList(LinkList head);//销毁链表操作

#include "链表.h"

void InitList(LinkList *head)//单链表的初始化操作
{
if((*head =(LinkList)malloc(sizeof(ListNode))) == NULL)
{
exit(-1);
}
(*head)->next = NULL;
}

int ListEmpty(LinkList head)//判断单链表是否为空
{
if(head->next == NULL)
{
return 1;
}
else
{
return 0;
}
}

ListNode* Get(LinkList head,int i)//按序号查找操作
{
ListNode *p;
int j = 0;
p = head;
if(ListEmpty(head))//在查找第i个元素之前，判断链表是否为空
{
return NULL;
}
if (i < 1)//在查找第i个元素之前，判断链表是否合法
{
return NULL;
}
while(p->next != NULL && j < i)
{
p = p->next ;
j++;
}
if(j == i)
{
return p;//找到第i个结点，返回指针p
}
else
{
return NULL;//如果没有找到第i个结点，返回NULL
}
}

ListNode* LocateElem(LinkList head,ElemType e)//按内容查找操作
{
ListNode *p;
p = head->next ;//指针p指向第一个节、结点
while(p)
{
if(p->data != e)//找到与e相等的元素，返回该序号
{
p = p->next ;
}
else
{
break;
}
}
return p;
}

int LocatePos(LinkList head,ElemType e)//定位操作
{
ListNode *p;
int i = 1;
if(ListEmpty(head))//在查找第i个元素之前，判断链表是否为空
{
return NULL;
}
p = head->next ;
while(p)
{
if(p->data == e)
{
return i;
}
else
{
p = p->next ;
i++;
}
}
if(!p)
{
return 0;
}
}

int InsertList(LinkList head,int i,ElemType e)//插入操作
{
ListNode *p,*pre;//定义指向第i个元素的前驱指针pre,指针p指向新生成的结点
int j = 0;
pre = head;//指针p指向头结点
while(pre->next != NULL && j < i-1)//找到i-1个结点，即第i个结点的前驱结点
{
pre = pre->next ;
j++;
}
if(j != i-1)//如果没找到则插入位置错误
{
printf("插入位置错误");
return 0;
}
if((p = (ListNode*)malloc(sizeof(ListNode))) == NULL)//新生成一个结点，并将e赋值给该结点的数据域
{
exit(-1);
}
p->data = e;
p->next = pre->next;//插入结点操作
pre->next = p;
return 1;
}

int DeleteList(LinkList head,int i,ElemType *e)//删除操作
{
ListNode *pre,*p;
pre = head;
int j = 0;
while(pre->next != NULL && pre->next->next != NULL && j < i-1)//判断是否找到前驱结点
{
pre = pre->next ;
j++;
}
if(j != i-1)//如果没有找到要删除的位置，说明删除结点位置错误
{
printf("删除位置错误");
return 0;
}
p = pre->next;//指针p指向单链表中的第i个结点，并将该结点的数据域值赋值给e
*e = p->data;
pre->next = p->next;//将前驱结点的指针域指向要删除结点的下一个结点，也就是将p指向的结点与单链表断开
free(p);//释放p指向的节点
return 1;
}

int ListLength(LinkList head)//求表长操作
{
ListNode *p;
int count = 0;
p = head;
while(p->next != NULL)
{
p = p->next ;
count++;
}
return count;
}

void DestroyList(LinkList head)//销毁链表操作
{
ListNode *p,*q;
p = head;
while(p != NULL)
{
q = p;
p = p->next ;
free(q);
}
}

#include "链表.h"
//单链表A和单链表B的元素都是非递减排列，利用单链表的基本运算，将它们合并成一个单链表C，要求C也是非递减序列。
void MergeList(LinkList A,LinkList B,LinkList *C)
{
ListNode *pa,*pb,*pc;
pa = A->next ;
pb = B->next ;
*C = A;
(*C)->next = NULL;
pc = *C;
while(pa && pb)
{
if(pa->data <= pb->data )
{
pc->next = pa;
pc = pa;
pa = pa->next ;
}
else
{
pc->next = pb;
pc = pb;
pb = pb->next ;
}
}
pc->next = pa ? pa : pb;
free(B);
}
int main(void)
{
int i;
ElemType a[] = {6,7,9,14,37,45,65,67};
ElemType b[] = {3,7,11,34,45,89};
LinkList A,B,C;
ListNode *p;
InitList(&A);
InitList(&B);
for(i = 1;i <= sizeof(a)/sizeof(a[0]);i++)
{
if(0 == InsertList(A,i,a[i-1]))
{
printf("位置不合法！");
return 0;
}
}
for(i = 1;i <= sizeof(b)/sizeof(b[0]);i++)
{
if(0 == InsertList(B,i,b[i-1]))
{
printf("位置不合法！");
return 0;
}
}
printf("单链表A中的元素有%d个\n",ListLength(A));
for(i = 1;i <= ListLength(A);i++)
{
p = Get(A,i);
if(p)
{
printf("%4d",p->data);
}
}
printf("\n");
printf("单链表B中的元素有%d个\n",ListLength(B));
for(i = 1;i <= ListLength(B);i++)
{
p = Get(B,i);
if(p)
{
printf("%4d",p->data);
}
}
printf("\n");
MergeList(A,B,&C);
printf("将单链表A和单链表B中的元素合并到单链表C中的元素有%d个\n",ListLength(C));
for(i = 1;i <= ListLength(C);i++)
{
p = Get(C,i);
if(p)
{
printf("%4d",p->data);
}
}
printf("\n");
return 0;
}