第二章 线性表(链表的建立与合并)

1.利用头插法和尾插法建立单链表

1.1利用尾插法建立单链表

typedef struct NODE//定义了一个结点
{
    int data;//数据域
    struct NODE * next ;//指针域

}NODE,*PNODE;

void createListT(PNODE &L,int a[], int n)
{//创建一个链表，在表尾插入
    int i = 0;//计时器的初值为0；
    PNODE pEnd;//创建一个指针时刻指向链表中的最后一个结点
    L = (PNODE)malloc(sizeof(NODE));//创建了一个头结点，并使L指向了头结点
    if(L==NULL)
    {
        printf("结点动态分配失败！！！\n");
        exit(-1);
    }
    L->next = NULL;
    pEnd = L;//使pL指向头结点

    while(i<n)
    {
        PNODE pnew = (PNODE)malloc(sizeof(NODE));//新建一个插入结点
        pnew->data = a[i++];//把数组中的值赋给新的结点的数据域

        pnew->next = pEnd->next;
        pEnd->next = pnew;//把新的结点插入在表尾
        pEnd = pEnd->next;//pEnd指向当前链表的最后一个结点
    }
}

1.2利用尾插法建立单链表

void createListH(PNODE &L, int a[], int n)
{//创建一个链表在表头插入
    int i = 0;//计时器的初值为0；
    L = (PNODE)malloc(sizeof(NODE));//创建一个头结点并使L指向头结点
    if(L == NULL)
    {
        printf("头结点内存分配失败！！！\n");
        exit(-1);
    }
    L->next = NULL;

    while(i<n)
    {
        PNODE pnew = (PNODE)malloc(sizeof(NODE));//创建一个插入结点，并使pnew指向插入节点

        pnew->data = a[i++];

        pnew->next = L->next;//让插入结点的指针域指向头结点的指针域
        L->next = pnew;//让头结点的指针域指向插入的结点，即插入的结点插在表头；
    }
}

2.链表的合并

2.1链表的合并（尾插法）

把两个非递减的链表合成，合成后的链表也是非递减的

void MergeListT(PNODE La,PNODE &Lb,PNODE &Lc)
{//两个非递减的链表的合并，合并后链表还是非递减的
    PNODE pa,pb,pc;
    pa = La->next;//pa指向La的第一个结点
    pb = Lb->next;//pb指向Lb的第一个结点
    free(Lb);//把Lb的头结点释放掉
    Lb = NULL;//Lb指向空
    Lc = La;//Lc利用La的头结点
    Lc->next = NULL;
    pc = Lc;//pc指向Lc头结点

    while (pa != NULL && pb != NULL)//循环结束后必有一个链表的元素全部插入到LC中
    {
        if(pa->data <= pb->data)
        {
            pc->next = pa;//把pa指向的结点链接在Lc中
            pa = pa->next;//pa指向下一个结点
            pc = pc->next;//pc指向下一个结点即链表Lc的当前尾结点
      //    Link(pc,pa);
        }
        else //否则的话将pb指向的结点连接在LC中
        {
            pc->next = pb;
            pb = pb->next;
            pc = pc->next;
          //Link(pc,pb);

        }
    }

由于下面这段代码的重复性过高，所以可以封装为一个函数
pc->next = pa;//把pa指向的结点链接在Lc中
pa = pa->next;//pa指向下一个结点
pc = pc->next;//pc指向下一个结点即链表Lc的当前尾结点

void LinkT(PNODE &pc,PNODE &pw)
{
    pc->next = pw;//把pa指向的结点链接在Lc中
    pw = pw->next;//pa指向下一个结点
    pc = pc->next;//pc指向下一个结点即链表Lc的当前尾结点
}

2.2链表的合并（头插法）

void MergeListH(PNODE La,PNODE &Lb,PNODE &Lc)
{//两个非递减的链表的合并，合并后链表是递减的
    PNODE pa,pb,pt;
    pa = La->next;//pa指向La的第一个结点
    pb = Lb->next;//pb指向Lb的第一个结点
    free(Lb);//把Lb的头结点释放掉
    Lb = NULL;//Lb指向空
    Lc = La;//Lc利用La的头结点
    Lc->next = NULL;

    while (pa != NULL && pb != NULL)//循环结束后必有一个链表的元素全部插入到LC中
    {
        if(pa->data <= pb->data)
        {
//            pt = pa;
//利用pt保存要插入的结点，然后pa指向下一个结点，如果不保存直接插入的话，就会丢失pa后面的结点
//            pa = pa->next;
//            pt->next = Lc->next;
//            Lc->next = pt;
            LinkH(Lc,pa);

        }
        else //否则的话将pb指向的结点连接在LC中
        {
//            pt = pb;
//            pb = pb->next;
//            pt->next = Lc->next;
//            Lc->next = pt;
            LinkH(Lc,pb);
        }
    }

    while(pa != NULL)
    {
//       pt = pa;
//       pa = pa->next;
//       pt->next = Lc->next;
//       Lc->next = pt;
        LinkH(Lc,pa);
    }
    while(pb != NULL)
    {
//        pt = pb;
//        pb = pb->next;
//        pt->next = Lc->next;
//        Lc->next = pt;
        LinkH(Lc,pb);
    }

}

由于下面这段代码的重复性过高，所以可以封装为一个函数
// pt = pa;
// pa = pa->next;
// pt->next = Lc->next;
// Lc->next = pt;

void LinkH(PNODE &Lc,PNODE &pw)
{
    PNODE pt = pw;
    pw = pw->next;
    pt->next = Lc->next;
    Lc->next = pt;
}