线性表（单链表）

先把代码贴上，之后再详解

操作

#include<stdio.h>
#include<stdlib.h>
/*自定义*/
#define INFEASIBLE 999999999/*超出线性表存储空间*/
#define OK 1
#define TRUE 1
#define FALSE 0
#define OVERFLOW 0/*溢出*/
#define ERROR 0/*错误*/
typedef int Status;
typedef int ElemType; 
/*线性表的单链表存储结构*/
typedef struct LNode{
    ElemType data;
    struct LNode *next;
}LNode,*LinkList;/* 另一种定义LinkList的方法 */

Status InitList(LinkList &L)
{
/* 操作结果：构造一个空的线性表L */
    L=(LinkList)malloc(sizeof(LNode));/* 产生头结点,并使L指向此头结点 */
    if(!L)/* 存储分配失败 */
     exit(OVERFLOW);
     L->next=NULL;/* 指针域为空 */
     return OK; 
}

Status DestroyList(LinkList &L)
{ 
/* 初始条件：线性表L已存在。操作结果：销毁线性表L */
   LinkList q;
   while(L)
   {
     q=L->next;
     free(L);
     L=q;
   }
   return OK;
}

Status ClearList(LinkList L) /* 不改变L */
{ 
/* 初始条件：线性表L已存在。操作结果：将L重置为空表 */
   LinkList p,q;
   p=L->next; /* p指向第一个结点 */
   while(p) /* 没到表尾 */
   {
     q=p->next;
     free(p);
     p=q;
   }
   L->next=NULL; /* 头结点指针域为空 */
   return OK;
}

Status ListEmpty(LinkList L)
{ 
/* 初始条件：线性表L已存在。操作结果：若L为空表，则返回TRUE，否则返回FALSE */
   if(L->next) /* 非空 */
     return FALSE;
   else
     return TRUE;
}

int ListLength(LinkList L)
{ 
/* 初始条件：线性表L已存在。操作结果：返回L中数据元素个数 */
   int LinkListLen=0;
   LinkList p=L->next; /* p指向第一个结点 */
   while(p) /* 没到表尾 */
   {
     LinkListLen++;
     p=p->next;
   }
   return LinkListLen;
}
Status GetElem(LinkList L,int i,ElemType &e)/* 算法2.8 */
{ 
 /* L为带头结点的单链表的头指针。当第i个元素存在时,其值赋给e并返回OK,否则返回ERROR */
   int j=1; /* j为计数器 */
   LinkList p=L->next; /* p指向第一个结点 */
   while(p&&j<i) /* 顺指针向后查找,直到p指向第i个元素或p为空 */
   {
     p=p->next;
     j++;
   }
   if(!p||j>i) /* 第i个元素不存在 */
     return ERROR;
   e=p->data; /* 取第i个元素 */
   return OK;
}

Status compare(ElemType c1,ElemType c2) /* 数据元素判定函数(平方关系) */
{
   if(c1==c2*c2)
     return TRUE;
   else
     return FALSE;
}

int LocateElem(LinkList L,ElemType e,Status(*compare)(ElemType,ElemType))
{ 
/* 初始条件: 线性表L已存在,compare()是数据元素判定函数(满足为1,否则为0) */
/* 操作结果: 返回L中第1个与e满足关系compare()的数据元素的位序。 */
/*           若这样的数据元素不存在,则返回值为0 */
   int i=0;
   LinkList p=L->next;
   while(p)
   {
     i++;
     if(compare(p->data,e)) /*找到这样的数据元素 */
       return i;
     p=p->next;
   }
   return 0;
}

Status PriorElem(LinkList L,ElemType cur_e,ElemType &pre_e)
{ 
/* 初始条件: 线性表L已存在 */
/* 操作结果: 若cur_e是L的数据元素,且不是第一个,则用pre_e返回它的前驱, */
/*           返回OK;否则操作失败,pre_e无定义,返回INFEASIBLE */
   LinkList q,p=L->next; /* p指向第一个结点 */
   while(p->next) /* p所指结点有后继 */
   {
     q=p->next; /* q为p的后继 */
     if(q->data==cur_e)
     {
       pre_e=p->data;
       return OK;
     }
     p=q; /* p向后移 */
   }
   return INFEASIBLE;
}

Status NextElem(LinkList L,ElemType cur_e,ElemType &next_e)
{ /* 初始条件：线性表L已存在 */
   /* 操作结果：若cur_e是L的数据元素，且不是最后一个，则用next_e返回它的后继， */
   /*           返回OK;否则操作失败，next_e无定义，返回INFEASIBLE */
   LinkList p=L->next; /* p指向第一个结点 */
   while(p->next) /* p所指结点有后继 */
   {
     if(p->data==cur_e)
     {
       next_e=p->next->data;
       return OK;
     }
     p=p->next;
   }
   return INFEASIBLE;
}

Status ListInsert(LinkList &L,int i,ElemType e) /* 算法2.9*/
{
/* 在带头结点的单链线性表L中第i个位置之前插入元素e */
    LinkList p=L;
    int j=0;
    while(p&&j<i-1)/* 顺指针向后查找，直到p指向第i-1个元素或p为空寻 */
    {
        p=p->next;
        ++j;
    }
    if(!p||j>i-1) /* i小于1或者大于表长 */
     return ERROR;
     LinkList s=(LinkList)malloc(sizeof(LNode));/* 生成新结点 */
     s->data=e;/* 插入L中 */
     s->next=p->next;
     p->next=s;
     return OK;
}

Status ListDelete(LinkList &L,int i,ElemType &e)/* 算法2.10*/
{
    LinkList p;
    int j=0;
    while(p->next&&j<i-1)/*寻找第i个结点,并令p指向其前趋 */
    {
        p=p->next;
        ++j;
    }
    if(!(p->next)||j>i-1)/* 删除位置不合理 */
     return ERROR;
     /*
     p->next=p->next->next;
     e=p->next->data;
     */
     LinkList q=p->next;/* 删除并释放结点 */
     p->next=q->next;
     e=q->data;
     free(q);
     return OK;
}

void visit(ElemType c) /* ListTraverse()调用的函数(类型要一致) */
{
   printf("%d ",c);
}

Status ListTraverse(LinkList L,void(*visit)(ElemType))
{
/* vi的形参类型为ElemType，与bo2-1.c中相应函数的形参类型ElemType&不同 */
/* 初始条件：线性表L已存在 */
/* 操作结果:依次对L的每个数据元素调用函数vi()。一旦vi()失败,则操作失败 */
   LinkList p=L->next;
   while(p)
   {
     visit(p->data);
     p=p->next;
   }
   printf("\n");
   return OK;
}
void CreateList(LinkList &L,int n) /* 算法2.11 */
{ 
/* 逆位序(插在表头)输入n个元素的值，建立带表头结构的单链线性表L */
   int i;
   L=(LinkList)malloc(sizeof(struct LNode));
   L->next=NULL; /* 先建立一个带头结点的单链表 */
   printf("请输入%d个数据\n",n);
   for(i=n;i>0;--i)
   {
     LinkList p=(LinkList)malloc(sizeof(struct LNode)); /* 生成新结点 */
     scanf("%d",&p->data); /* 输入元素值 */
     p->next=L->next; /* 插入到表头 */
     L->next=p;
   }
}

void CreateList2(LinkList &L,int n)
{ /* 正位序(插在表尾)输入n个元素的值，建立带表头结构的单链线性表 */
   int i;
   LinkList p,q;
   L=(LinkList)malloc(sizeof(struct LNode)); /* 生成头结点 */
   L->next=NULL;
   q=L;
   printf("请输入%d个数据\n",n);
   for(i=1;i<=n;i++)
   {
     p=(LinkList)malloc(sizeof(struct LNode));
     scanf("%d",&p->data);
     q->next=p;
     q=q->next;
   }
   p->next=NULL;
}
void MergeList(LinkList La,LinkList Lb,LinkList &Lc) /* 算法2.2,此句与algo2-2.c不同 */
{
/* 已知线性表La和Lb中的数据元素按值非递减排列。 */
/* 归并La和Lb得到新的线性表Lc,Lc的数据元素也按值非递减排列 */
   int i=1,j=1,k=0;
   int La_len,Lb_len;
   ElemType ai,bj;
   InitList(Lc); /* 创建空表Lc */
   La_len=ListLength(La);
   Lb_len=ListLength(Lb);
   while(i<=La_len&&j<=Lb_len) /* 表La和表Lb均非空 */
   {
     GetElem(La,i,ai);
     GetElem(Lb,j,bj);
     if(ai<=bj)
     {
       ListInsert(Lc,++k,ai);
       ++i;
     }
     else
     {
       ListInsert(Lc,++k,bj);
       ++j;
     }
   }
   while(i<=La_len) /* 表La非空且表Lb空 */
   {
     GetElem(La,i++,ai);
     ListInsert(Lc,++k,ai);
   }
   while(j<=Lb_len) /* 表Lb非空且表La空 */
   {
     GetElem(Lb,j++,bj);
     ListInsert(Lc,++k,bj);
   }
}

void MergeList_L(LinkList &La,LinkList &Lb,LinkList &Lc)/*算法2.12*/
{
/* 已知单链线性表La和Lb的元素按值非递减排列。 */
/* 归并La和Lb得到新的单链线性表Lc，Lc的元素也按值非递减排列 */
    LinkList pa,pb,pc; 
    pa=La->next;
    pb=Lb->next;
    Lc=pc=La;/* 用La的头结点作为Lc的头结点 */
    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(Lb);/* 释放Lb的头结点 */
}
Status equal(ElemType c1,ElemType c2)
{
/* 判断是否相等的函数，Union()用到 */
   if(c1==c2)
     return TRUE;
   else
     return FALSE;
}

void Union(LinkList &La,LinkList Lb) /* 算法2.1,此句与algo2-1.c不同 */
{/* 将所有在线性表Lb中但不在La中的数据元素插入到La中 */
   ElemType e;
   int La_len,Lb_len;
   int i;
   La_len=ListLength(La); /* 求线性表的长度 */
   Lb_len=ListLength(Lb);
   for(i=1;i<=Lb_len;i++)
   {
     GetElem(Lb,i,e); /* 取Lb中第i个数据元素赋给e */
     if(!LocateElem(La,e,equal)) /* La中不存在和e相同的元素,则插入之 */
       ListInsert(La,++La_len,e);
   }
}

main函数

void CreateList_main()
{
   int n=5;
   LinkList La,Lb,Lc;
   printf("按非递减顺序, ");
   CreateList2(La,n); /* 正位序输入n个元素的值 */
   printf("La="); /* 输出链表La的内容 */
   ListTraverse(La,visit);
   printf("按非递增顺序, ");
   CreateList(Lb,n); /* 逆位序输入n个元素的值 */
   printf("Lb="); /* 输出链表Lb的内容 */
   ListTraverse(Lb,visit);
   MergeList_L(La,Lb,Lc); /* 按非递减顺序归并La和Lb,得到新表Lc */
   printf("Lc="); /* 输出链表Lc的内容 */
   ListTraverse(Lc,visit);
}

void Union_main()
{
   LinkList La,Lb; /* 此句与algo2-1.c不同(因为采用不同的结构) */
   Status i;
   int j;
   i=InitList(La);
   if(i==1) /* 创建空表La成功 */
     for(j=1;j<=5;j++) /* 在表La中插入5个元素 */
       i=ListInsert(La,j,j);
   printf("La= "); /* 输出表La的内容 */
   ListTraverse(La,visit);
   InitList(Lb); /* 也可不判断是否创建成功 */
   for(j=1;j<=5;j++) /* 在表Lb中插入5个元素 */
     i=ListInsert(Lb,j,2*j);
   printf("Lb= "); /* 输出表Lb的内容 */
   ListTraverse(Lb,visit);
   Union(La,Lb);
   printf("new La= "); /* 输出新表La的内容 */
   ListTraverse(La,visit);
}
void MergeList_main()
{
   LinkList La,Lb,Lc; 
   int j,a[4]={3,5,8,11},b[7]={2,6,8,9,11,15,20};
   InitList(La); /* 创建空表La */
   for(j=1;j<=4;j++) /* 在表La中插入4个元素 */
     ListInsert(La,j,a[j-1]);
   printf("La= "); /* 输出表La的内容 */
   ListTraverse(La,visit);
   InitList(Lb); /* 创建空表Lb */
   for(j=1;j<=7;j++) /* 在表Lb中插入7个元素 */
     ListInsert(Lb,j,b[j-1]);
   printf("Lb= "); /* 输出表Lb的内容 */
   ListTraverse(Lb,visit);
   MergeList(La,Lb,Lc);
   printf("Lc= "); /* 输出表Lc的内容 */
   ListTraverse(Lc,visit);
}

int main()
{
    printf("---------------------------------------------\nCreateList_main():\n");
    CreateList_main();
    printf("---------------------------------------------\nUnion_main():\n");
    Union_main();
    printf("---------------------------------------------\nMergeList_main():\n");
    MergeList_main();
    printf("---------------------------------------------\n");
    return 0;
}