已知两个排列递增的单链表A和B，编写算法将它们合并成一个链表C而不改变其排序性

#include <stdio.h>
#include <stdlib.h>

typedef struct node
{
    int data;
    struct node*next;
}Lnode,*Linklist;
Linklist init()
{
    Lnode *s;
    s=(Linklist)malloc(sizeof(Lnode));
    s->data=0;
    s->next=NULL;
    return s;
}
Linklist creat()//输入时需满足是递增数列
{
    Lnode *s,*r;
    int x,flag=1;
    Linklist L;
    L=(Lnode *)malloc(sizeof(Lnode));//需开辟空间否则无法使数据存入进去
    L->next=NULL;
    r=L;
    printf("please input the nums of table\n");
    scanf("%d",&x);
    while(flag)
    {
        s=(Linklist)malloc(sizeof(Lnode));
        s->data=x;
        s->next=NULL;
        r->next=s;
        r=s;
        scanf("%d",&x);
        if(x==-1)
        flag=0;
    }
    return L;
}
Linklist result(Linklist A,Linklist B)//A,B含头结点
{
    Lnode *p,*q,*s;
    Linklist C;
    p=A->next;q=B->next;//分别指向第一个结点
    C=A;
    s=C;
    free(B);
    while(p&&q)
    {
        if(p->data<q->data)
        {
            s->next=p;
            s=p;
            p=p->next;
        }
        else
        {
            s->next=q;
            s=q;
            q=q->next;
        }
    }
    if(p)
        s->next=p;
    else
        s->next=q;
   return C;
}
int main()
{
    Linklist A,B,C;
    A=creat();
    B=creat();
    C=result(A,B);
    while(C)
    {
        C=C->next;//含头结点，所以从第一个结点开始输出
        printf("%d ",C->data);
    }
    return 0;
}

 已知两个排列递增的单链表A和B，编写算法求A和B的交集链表C，并且同样已元素递增的形式存储

#include <stdio.h>
#include <stdlib.h>
typedef struct node
{
    int data;
    struct node*next;
} Lnode,*Linklist;
Linklist init()
{
    Lnode *s;
    s=(Linklist)malloc(sizeof(Lnode));
    s->data=0;
    s->next=NULL;
    return s;
}
Linklist creat()//输入时需满足是递增数列
{
    Lnode *s,*r;
    int x,flag=1;
    Linklist L;
    L=(Lnode *)malloc(sizeof(Lnode));//需开辟空间否则无法使数据存入进去
    L->next=NULL;
    r=L;
    printf("please input the nums of table\n");
    scanf("%d",&x);
    while(flag)
    {
        s=(Linklist)malloc(sizeof(Lnode));
        s->data=x;
        s->next=NULL;//创建输入链表时这里设置了使链表尾空
        r->next=s;
        r=s;
        scanf("%d",&x);
        if(x==-1)
            flag=0;
    }
    return L;
}
Linklist result(Linklist A,Linklist B)//A,B含头结点
{
    Lnode *p,*q,*s,*r;
    Linklist C;
    C=(Linklist)malloc(sizeof(Lnode));
    p=A->next;
    q=B->next;//分别指向第一个结点
    r=C;
    free(B);
    while(p&&q)
    {
        if(p->data==q->data)
        {
            s=(Linklist)malloc(sizeof(Lnode));
            s->data=p->data;//利用尾插形式，无法用新开结点之后s=s->next
            r->next=s;
            r=s;
            p=p->next;
            q=q->next;
        }
        else if(p->data<q->data)
            p=p->next;
        else
            q=q->next;
    }
    r->next=NULL;//使尾端为空，不然输出时是无限循环
    //方式二  //r=C->next;//这里指向第一个结点，所以输出时->next写在后头，若为这样处理，则先->next
    //方式二 //free(C);return r;
    return C;
}
int main()
{
    Linklist A,B,C;
    A=creat();
    B=creat();
    C=result(A,B);
    while(C)
    {
        C=C->next;//含头结点，所以从第一个结点开始输出
        printf("%d ",C->data);
       //方式二 //printf("%d ",C->data);C=C->next;
    }
    return 0;
}

变式：

A和B两个单链表递增有序排列，求出A和B的交集C，仍然以递增的单链表排序。

输入输出样例：1组

#1

• 样例输入：

  5 //A链表中包含的元素个数
  1 2 3 4 5 //A链表中的元素
  4 //B链表中包含的元素个数
  3 4 5 6 //B链表中的元素

 这里注意一下最后判断C结束条件：node->next！=NULL和node!=NULL的区别

这里我们利用尾插将最后结点的指针域设为NULL，而node！=NULL则判断C是不是空，有可能node结点不存在，而node->next！=NULL则是node结点存在而指针域为NULL

//注意
    //1:该程序每次运行的时间必须小于10秒，否则会超时,程序超时将不会测试剩余的测试集
    //2:该程序每次运行使用的内存不能超过1M，否则会返回错误
    //3:该程序每次运行输出的结果最多显示1000个字符(多余的不显示),每行末尾的所有空格用□表示
#include <stdio.h>
#include <stdlib.h>
typedef struct node
{
    int data;
    struct node*next;
} Lnode,*Linklist;
Linklist init()
{
    Lnode *s;
    s=(Linklist)malloc(sizeof(Lnode));
    s->data=0;
    s->next=NULL;
    return s;
}
Linklist creat(int count)//输入时需满足是递增数列
{
    Lnode *s,*r;int num=0;
    int x;
    Linklist L;
    L=(Lnode *)malloc(sizeof(Lnode));//需开辟空间否则无法使数据存入进去
    L->next=NULL;
    r=L;
    //printf("please input the nums of table\n");
    while(num<count)
    {
        scanf("%d",&x);
        s=(Linklist)malloc(sizeof(Lnode));
        s->data=x;
        s->next=NULL;//创建输入链表时这里设置了使链表尾空
        r->next=s;
        r=s;
        num++;
    }
    return L;
}
Linklist result(Linklist A,Linklist B)//A,B含头结点
{
    Lnode *p,*q,*s,*r;
    Linklist C;
    C=(Linklist)malloc(sizeof(Lnode));
    p=A->next;
    q=B->next;//分别指向第一个结点
    r=C;
    free(B);
    while(p&&q)
    {
        if(p->data==q->data)
        {
            s=(Linklist)malloc(sizeof(Lnode));
            s->data=p->data;
            r->next=s;//利用尾插形式，无法用新开结点之后s=s->next
            r=s;
            p=p->next;
            q=q->next;
        }
        else if(p->data<q->data)
            p=p->next;
        else
            q=q->next;
    }
    r->next=NULL;//使尾端为空，不然输出时是无限循环
    //方式二  //r=C->next;//这里指向第一个结点，所以输出时->next写在后头，若为这样处理，则先->next
    //方式二 //free(C);return r;
    return C;
}
int main()
{
    Linklist A,B,C;int m,n;
    scanf("%d",&m);
    A=creat(m);
    scanf("%d",&n);
    B=creat(n);
    C=result(A,B);
    while(C->next!=NULL)
    {
        C=C->next;//含头结点，所以从第一个结点开始输出
        printf("%d ",C->data);
       //方式二 //printf("%d ",C->data);C=C->next;
    }
    return 0;
}