实际应用中带头节点的线性链表

/*========带头节点的线性链表类型=========*/
typedef char ElemType

//结点类型
typedef struct LNode
{
char data;
struct LNode *next;
}*Link,*Position;

//链表类型
typedef struct
{
Link head,tail;
int len;
}LinkList;

/*======================================================*/
/*=======一些在其他函数定义中会调用的函数===============*/
/*======================================================*/

/*---compare---比较两个元素的大小关系*/
int Compare(char a,char b)
{
return a-b;
}

/*---visit---*/
int Visit(Link p)
{
if(...)
return 1;
else
return 0;

}

/*---length---求链的长度*/
int Length(Link s)
{
int i=0;
Link p=NULL;
p=s;
while(p->next!=NULL)
{
p=p->next;
i++;
}
return i;
}

/*---print---在屏幕上输出链表的所有元素*/
void Print(LinkList L)
{
Link p=NULL;
p=L.head;
if(!p->next)
{
printf("\nThe LinkList is empty.\n\n");
return ;
}
printf("The List:");
while(p)
{
printf("%c-",p->data);
p=p->next;
}
}

/*======================================================*/
/*==========对带头结点的单链线性表进行操作的函数的定义==*/
/*======================================================*/

/*---分配由p指向的结点并赋值为e---*/
Position MakeNode(ElemType e)
{
Link p=NULL;
p=(Link)malloc(sizeof(struct LNode));
if(p)
{
p->data=e;
p->next=NULL;
}
else return;
return p;
}

/*---释放p所指向的结点-*/
void FreeNode(Link p)
{
free(p);
}

/*---构造一个由L指向的空的线性表-*/
void InitList(LinkList *L)
{
L->head=MakeNode('L');//生成头结点
L->head->next=NULL;/*不是l->head=NULL*/
L->tail=L->head;
L->len=0;
}

/*----------销毁由L指向的线性表---------*/
void DestroyList(LinkList *L)
{
Link p;
p=(*L).tail;
while(p!=(*L).head)
{
p=PriorPos(*L,p);
FreeNode(p->next);
}
FreeNode((*L).head);
}

/*将线性表L置为空表，并释放原链表的头结点*/
void ClearList(LinkList *L)
{
Link p;
p=(*L).tail;
while(p!=(*L).head)
{
p=PriorPos(*L,p);
FreeNode(p->next);
}
FreeNode((*L).head);
}

/*---将s指向的结点插入线性链表的第一个结点之前-*/
void InsFirst(LinkList *L,Link s)
{
s->next=L->head->next;
if(!L->head->next)
L->tail=s;       /*当向一个空的线性表执行该操作时*/
L->head->next=s;
L->len++;
}

/*---删除表中第一个结点并以q返回-*/
void DelFirst(LinkList *L,Link q)
{
if(!L->head->next)
{
printf("\nThe LinkList is empty,can not delete..\n");
return 0;
}
q=L->head->next;
L->head->next=L->head->next->next;
}

/*---将指针s所的一串结点链接在线性表L的最后一个结点-*/
void Append(LinkList *L,Link s)
{
Link q;
q=L->head;
if(!L->tail)
{/*考虑到链表为空的情况*/
L->head->next=s;
while(q->next)
q=q->next;/*尾结点的处理*/
L->tail=q;
}
L->tail->next=q=s;
while(q->next)
q=q->next;/*不能忘了对尾结点的处理*/
L->tail=q;
L->len+=Length(s);
}

/*---删除线性表l中的尾结点-*/
void Remove(LinkList *L,Link q)
{
if(!L->tail)
{
printf("\nthe LinkList is empty,can not remonde..\n");
return 0;
}
q=L->tail;
L->tail=PriorPos(*L,q);
L->tail->next=NULL;
}

/*---将s所指向结点插入在p所指结点之前-*/
void InsBefore(LinkList *L,Link p,Link s)
{
Link q;
q=PriorPos(*L,p);
s->next=p;
q->next=s;
}

/*---将s所指向结点插入在p所指结点之后-*/
void InsAfter(LinkList *L,Link p,Link s)
{
s->next=p->next;
p->next=s;
}

/*---用e更新p所指向的当前结点-*/
void SetCurElem(Link p,ElemType e)
{
p->data=e;
}

/*---返回p所指结点中元素的值-*/
ElemType GetCurElem(Link p)
{
return p->data;
}

int Listempty(LinkList L)
{         /*---若线性表为空表则返回1，否则返回0-*/
if(L.head==L.tail)
return 1;
return 0;
}

int Listlength(LinkList L)
{      /*---返回线性表中元素个数-*/
return L.len;
}

Position GetHead(LinkList L)
{     /*---返回线性表l中头结点的位置-*/
return L.head;
}

Position GetLast(LinkList L)
{      /*-----返回线性表l中最后一个结点的位置-------*/
return L.tail;
}

/*---返回p所指结点的直接前驱的位置-*/
Position PriorPos(LinkList L,Link p)
{
Link q;
q=L.head;
if(q->next==p)
return 0;
while(q->next!=p)
q=q->next;
return q;
}

/*-----返回p所指结点的直接后继的位置-------*/
Position NextPos(Link p)
{
Link q;
q=p->next;
return q;
}

/*-----用p返回线性表l中第i个结点的位置，并返回ok-------*/
void LocatePos(LinkList L,int i,Link p)
{
p=L.head;
if(i<=0||i>Listlength(L))
return 0;
while(i)
{
p=p->next;
i--;
}
}

/*----返回表中第一个与e满足一定函数关系的结点次序位置----*/
int LocatElem(LinkList L,ElemType e)
{
int i=0;
Link p;
p=L.head->next;
while(compare(p->data,e)&&p)
{
p=p->next;
++i;
}
if(!p)
{/*考虑到查找不到指定元素的情况*/
printf("\nthere's no '%c' in this LinkList.",e);
return 0;
}
return i;
}

/*----用一个函数遍历表中所有结点-------*/
void ListTraverse(LinkList L)
{
Link p;
p=L.head;
while(!visit(p))
p=p->next;
}

将单链线性表La和Lb的元素按值非递减排列

Status MergeList_L(NLinkList &La, NLinkList &Lb, NLinkList &Lc,
int (*compare)(ElemType, ElemType))
{
// 算法2.21
// 已知单链线性表La和Lb的元素按值非递减排列。
// 归并La和Lb得到新的单链线性表Lc，Lc的元素也按值非递减排列。
NLink ha, hb;
Position pa, pb, q;
ElemType a, b;
if (!InitList(Lc))
return ERROR; // 存储空间分配失败
ha = GetHead(La); // ha和hb分别指向La和Lb的头结点
hb = GetHead(Lb);
pa = NextPos(La, ha); // pa和pb分别指向La和Lb中当前结点
pb = NextPos(Lb, hb);
while (pa && pb)
{ // La和Lb均非空
a = GetCurElem(pa); // a和b为两表中当前比较元素
b = GetCurElem(pb);
if ((*compare)(a, b)<=0)
{ // a≤b
DelFirst(ha, q); Append(Lc, q); pa = NextPos(La, pa);
}
else
{ // a＞b
DelFirst(hb, q); Append(Lc, q); pb = NextPos(Lb, pb);
}
} // while
if (pa)
Append(Lc, pa); // 链接La中剩余结点
else
Append(Lc, pb); // 链接Lb中剩余结点
FreeNode(ha);
FreeNode(hb); // 释放La和Lb的头结点
return OK;
} // MergeList_L