链表应用举例

例一：求表长
设一个移动工作指针p和一个计数器j，初始时p=L->next，J=0，若p非空，则计数器加1，并将指针下移一个位置，直到达链表尾，算法描述如下：

int LinkListLen(LinkList L)
{
//求带头结点的单链表L的长度
    LNode *p
    int j=0;
    p=L->next;//p指向第一个结点
    while(p){j++;p=p->next;}//p指向第j个节点
    return j;
}

例二：编写一个将单循环链表逆置的算法
解： 设置一个工作指针p，初始指向单循环链表L的第一结点，将L的next域指向L，即建立一个空单循环链表，然后采用头插法将所有结点插入到单循环链表L中，算法如下：

int conrrayCirLinkList(CirLinkList &L){//头插法建立
    LNode *p ,*q;
    p=->next;
    L->next=L;//建立空单循环链表
    while(p!=L)
    {
        q=p;
        p=p->next;
        q->next=L->next;
        L->next=q;
    }
    return OK;
}

例三：一直有两个带头结点的循环单链表，设计一个算法，用最快速度将这两个表合成一个带头结点的循环单链表。要求时间复杂度O(1),且占用辅助空间最小。

解： 根据要求，只有设尾指针的单循环链表才能实现。算法如下：

void UnionCirLinkList(CirLinkList &Ls,CirLinkList &Lb){
//La和Lb是带头结点的单循环链表
    LNode *q;
    q=Lb->next;//q指向Lb的头结点
    Lb->next=La->next;//Lb的后继结点为La的头结点
    La->next=q->next;//La的后继结点为原Lb的第一个元素结点
    delete q;//释放原Lb的头结点
    }

例四：
将两个有序表La和Lb归并成一个有序表，要求不能另设新空间。
解： 算法如下

void mergelist(LinkList &La,LinkList &Lb,LinkList &Lb)
{
LinkList pa,pb,pc;
pa=La->next;pb=Lb->next;
Lc=pc=La;
while(pa&&pb)
{
    if(pa->data<=pb->data)
    {
        pc->next=pa;
        pc=pa;
        pa=pc->next;        
    }
    else
    {
        pc->next=pb;
        pc=pb;
        pb=pb->next;
    }
}
if(!pa)pc->next=pb;
if(!pb)pc->next=pa;
delete Lb;
}

例五： 一元稀疏多项式相加。
解： 链表的存储结构如下：

typedef struct
{
    float coef;//系数
    int expn;//指数
}term,ElemType;
typedef struct Lnode
{
    Elemtype data;
    struct Lnode *next;
}Lnode,*LinkList

对于两个一元多项式所有指数相同的项，将对应系数相加，若其和不为0，则构成“和多项式”中的一项；对两个一元多项式中指数不同的项，则分别复抄到“和多项式”中。
算法描述如下：

void addlist(LinkList &La,LinkList &Lb)
{
    pa=La->next;
    pb=Lb->next;
    pc=pa;//指向链表当前结尾点
    while(pa&&pb)
    {
        if(pa->data.expn<pb->data.expn)
        {
            pc->next=pa;
            pc=pa;
            pa=pa->next;
        }
        else
            if(pa->data.expn<pb->data.expn)
            {
                pc->next=pb;
                pc=pb;
                pb=pa->next;
            }
    else
    {
        sum=pa->data.coef + pb->data.coef;
        if(sum==0)
        {
            p=pa;
            pa=pa->next;
            delete p;
            p=pb;
            pb=pb->next;
            delete p;
        }
        else
        {
            pa->data.coef=sum;
            pc->next=pa;
            pc=pa;
            pa=pa->next;
            p=pb;
            pb=pb->next;
            delete p;
        }
    }
    }
    if(pa)pc->next=pa;
    if(pb)pc->next=pb;
    delete Lb;//释放Lb头指针
}

例六： 设L是带头结点的头指针，试编写算法，按照递增次序输出单链表各节点的数据元素，并释放所占的存储空间。要求不允许使用数组作为辅助空间。
解： 应对链表进行遍历，每次遍历中查找出整个链表的最小元素，输出并释放头结点所占空间。算法如下：

void deleteMin(LinkList &L)
{
    LNode *pre,*p,*q;
    while(L->next)
    {
        pre=L;
        p=L->next;//p为工作指针
        while(p->next)
            if(p->next->data < pre->next->data)
            {
                pre=p;
                p=p->next;
            }
            else
                p=p->next;
            printf("%d",pre->next->data);//输出元素最小结点的数据
            q=pre->next;
            pre->next=q->next;
            delete (q);//删除元素最小结点
    }
    delete （L）；//释放头结点
}

例七： 有一个双向链表从第二个结点到表尾递增有序。试编写算法，将第一个结点删除并插入到适当位置，使整个链表递增有序。
解： 算法如下：

void insertnode(DuLinkLinst &L)
{
    DuNode *p,*q,*r;
    p=L->next;
    L->next=p->next;
    p->next->prior=L;
    q=L->next;//q为工作指针
    r=L;//r为q的前驱
    while (q&&q->data < p->data)
    {
        r=q;
        q=q->next;
    }
    if(q)
    {
        q->prior->next=p;
        p->prior=q->prior;
        p->next=q;
        q->prior=p;
    }
    else
    {//插在尾部
        p->next=r->next;
        r->next=q;
        p->prior=r;
    }
}

终于要下雨了，热成狗了！