《数据结构》2.6单链表应用举例

//单链表倒置（头插法，时间复杂度O(n)）
/*算法思路:
    依次取出原链表中的每个节点，每次都将其作为第一个节点插入原链表中；由于采用头插法，插入顺序与取节点
顺序正好相反，故可以完成倒置操作。
*/
void reverseList(LinkList h)        //reverse：背面、相反、颠倒
{
    LNode *p;
    p = h->next;                    //*p指向第一个数据元素节点
    h->next = NULL;                    //将原链表置为空表
    while(p)
    {
        q = p;
        p = p->next;
        q->next = h->next;            //将第一个节点插到当前节点的后面（即当前节点插到了头节点的后面）
        h->next = q;
    }
}

//重复节点的删除（单链表中数据域值相同的节点称为重复节点，时间复杂度O(n*n)）
/*算法思路：
    用指针p指向第一个数据节点，从它的直接后继节点开始直到链表的结束，找到与其值相同的节点并删除；p指向
下一节点，重复上述操作；依此类推；当p指向表尾节点时算法结束。
*/
void del_LinkList(LinkList h)
{
    LNode *p, *q, *r;
    p = L->next;                    //p指向第一个节点
    if(p = NULL) return 0;
    while(q->next)
    {
        q = p;
        while(q->next)                //从p的后继开始查找重复节点
        {
            if(q->next->data == p->data)
            {
                r = q->next;        //r指向重复节点
                q->next = r->next;
                free(r);            //删除r
            }
            else
                q = q->next;
        }
        p = p->next;                //p指向下一个节点
    }
}

//单链表的合并（头插法，时间复杂度O(m+n)，合并：merge）
//两个单链表A、B中元素均为递增有序，现将A、B归并一个按元素值非递增（允许有相同值）有序单链表C，不需要重新申请节点。
/*算法思路：
    利用A、B递增有序的特点，依次取出当前节点进行比较，将当前值较小者取下，插入C的头部；由于采用的是
头插法，最先找到的最小值节点将会在C的尾部；依此类推，所以得到的C为非递增有序的单链表。
*/
LinkList merge_LinkList(LinkList A, LinkList B) //A、B均为带头节点的单链表
{
    LinkList C;
    LNode *p, *q, *r;
    p = A->next;
    q = B->next;
    c = A;                            //C的头节点
    c->next = NULL;
    free(B);                        //释放B的头节点
    while(p && q)
    {
        if(p->data < q->data)
        {
            r = p; p = p->next;
        }
        else
        {
            r = q; q = q->next;        //从原A、B上取下较小值的节点
            r->next = C->next;        //将第一个节点插到当前节点的后面（即插入到C的头部）
            C->next = r;
        }
        if(p == NULL) p = q;
        while(p)                    //将剩余的节点一个个取下，插入C的头部
        {
            r = p; p = p->next;
            r->next = C->next;
            C->next = r;
        }
    }
}

//一元多项式的表示及相加（时间复杂度O(m+n)）
/*    在数学上，一个n元多项式可以表示为Pn(x)=p0+p1*x+p2*x^2+…+pn*x^n，该多项式由n+1个系数唯一确定。
在计算机里，可以用一个线性表P来表示，即P=(p0,p1,p2,…pn)，每项的指数i隐含在其系数pi的序号里。同理，
Qm(x)表示为Q=(q0,q1,q2,…qm),设m<n,相加结果Rn(x)表示为R=(p0+q0,p1+q1,p2+q2,…,pm+qm,pm+1,…,pn)。
    为了有效而合理的利用存储空间，对于系数为0的所有项全都不存储，只存储非0项的系数及其相应的指数。
算法思路：
    设PA和PB分别为两个参与运算多项式的头指针，PC为结果链表头指针，指针ha和hb分别指向多项式PA和PB中当前进行比较的节点；
比较两个节点的指数项，进行如下操作。
    （1）指针ha所指节点的指数值小于指针hb所指节点的指数值，将ha所指节点插入PC链尾，指针ha后移一个节点；
    （2）指针ha所指节点的指数值等于指针hb所指节点的指数值，将ha和hb两个节点的系数相加，若系数之和为零，则删除两节点；
若系数之和不为零，则将两者系数之和赋值给ha所指节点且插入PC链尾，删除hb所指节点；
    （3）指针ha所指节点的指数值大于指针hb所指节点的指数值，将hb所指节点插入PC链尾，指针hb后移一个节点。
    若PA和PB中有一个链表先行比较完毕，那么另一个未比较完链表的余下部分可直接连接到PC链表的表尾。
*/
//定义节点
typedef struct Lnode
{
    float coef;                        //系数（coeficient）
    int exp;                        //指数（exponent）
    struct Lnode *next;
}Lnode, *LinkList;
//多项式相加
void Add(Lnode *PA, Lnode *PB, Lnode *PC)
{
    Lnode *ha, *hb, *temp;
    int sum;
    ha = PA->next;
    hb = PB->next;
    PC = PA;                        //PC指针最初是指向结果链的表头
    while(ha != NULL && hb !=NULL)
    {
        if(ha->exp < hb->exp)
        {
            PC->next = ha; PC = PC->next; ha = ha->next; //PC此时变为移动指针，指向结果链当前节点
        }
        else if(ha->exp == hb->exp)
        {
            sum = ha->coef + ha->coef;
            if(sum != 0)            //如果系数和不为零
            {
                ha->coef = sum;
                PC->next = ha; PC = PC->next; ha = ha->next;
                temp = hb; hb = hb->next; free(temp);
            }
            else                    //如果系数和为零，则删除节点ha与hb，并将两指针分别指向下一个节点
            {
                temp = ha; ha = ha->next; free(temp);
                temp = hb; hb = hb->next; free(temp);
            }
        }
        else                        //ha=>exp > hb->exp;
        {
            PC->next = hb; PC = PC->next; hb = hb->next;
        }
    }
    if(ha != NULL)                    //将多项式PA中剩余的节点连接到PC中
        PC->next = ha;
    else                            //将多项式PB中剩余的节点连接到PC中
        PC->next = hb;
        PC = PA;                    //PC指针恢复为指向结果链表头
        free(PB);                    //释放掉剩余的PB头指针
}