链表合并，不知道为什么通过不了，

[你的小小栗子]

/*
题目描述
已有a、b两个链表，每个链表中的结点包括学号、成绩。要求把两个链表合并，按学号升序排列。

输入
第一行，a、b两个链表元素的数量N、M,用空格隔开。 接下来N行是a的数据 然后M行是b的数据 每行数据由学号和成绩两部分组成

输出
按照学号升序排列的数据

样例输入
2 3
5 100
6 89
3 82
4 95
2 10
样例输出
2 10
3 82
4 95
5 100
6 89
*/
/*
typedef struct Node
{
char cNum[30];
int score;
struct Node * pNext;
}node;
//创建链表
node* Createlist(node *Head,int n)
{
node *pNew,*pTemp;
int cnt=0;
Head=NULL;
pNew=pTemp=(node *)malloc(sizeof(node));

while(cnt<n)
{
if(cnt==0)
{
scanf("%s %d",pNew->cNum,&pNew->score);
pNew->pNext=NULL;
pTemp=pNew;
Head=pTemp;
cnt++;
}
else
{
pNew=(node *)malloc(sizeof(node));
scanf("%s %d",pNew->cNum,&pNew->score);
pNew->pNext=NULL;
pTemp->pNext=pNew;
pTemp=pNew;
cnt++;
}
}

return Head;
}
//合并链表
node* Combinelist(node* Head1,node* Head2)
{
node* Head=Head1;
node* pTemp=(node *)malloc(sizeof(node));
while(Head1!=NULL)
{
pTemp=Head1;
Head1=Head1->pNext;
}
pTemp->pNext=Head2;
free(Head1);
return Head;
}
//排序链表
node* sort(node* Head,int n,int m)
{

int i,j;
int cnt=n+m;
node* pTemp;
char Tempnum[30];
int Tempscore;
node * Newhead=Head;
pTemp=(node *)malloc(sizeof(node));
for(i=0;i<cnt-1;i++)
{
for(j=0;j<cnt-1-i;j++)
{
pTemp=Head;
Head=Head->pNext;
if(strcmp(pTemp->cNum,Head->cNum)>0)
{
strcpy(Tempnum,Head->cNum);
Tempscore=Head->score;

strcpy(Head->cNum,pTemp->cNum);
Head->score=pTemp->score;

strcpy(pTemp->cNum,Tempnum);
pTemp->score=Tempscore;

}

}
Head=Newhead;
}

return Newhead;

}
//输出链表
node* Printlist(node* Head)
{

node * Newhead=Head;
while(Head!=NULL)
{
printf("%s %d\n",Head->cNum,Head->score);
Head=Head->pNext;
}
return Newhead;
}
int main()
{
node *Head1=NULL;
node *Head2=NULL;
node *Head=NULL;
int N,M;
scanf("%d %d",&N,&M);
getchar();
Head1=Createlist(Head1,N);
Head2=Createlist(Head2,M);
Head=Combinelist(Head1,Head2);
Head=sort(Head,N,M);
Printlist(Head);
return 0;
}*/

[你的小小栗子]

样例可以通过，空链表也没问题，但是在oj上通过不了，真没办法了，上来问问大家

[遇见女神]

学号用整数类型保存而不是char数组

[真相重于对错]

题目出的有问题，你的也太复杂

[自信男孩]

楼主没按照学号升序合并呢

[qiu_shaofeng]

if(strcmp(pTemp->cNum,Head->cNum)>0) 比较不出学号大小

[你的小小栗子]

引用 5 楼 自信男孩的回复:

楼主没按照学号升序合并呢

有的，样例可以通过

[你的小小栗子]

引用 3 楼 遇见女神的回复:

学号用整数类型保存而不是char数组

用字符数组也可以吧，我感觉和这个没啥关系

[自信男孩]

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

typedef struct Node
{
    char cNum[30];
    int score;
    struct Node *pNext;
}node;

//创建链表
node*  Createlist(node *Head,int n)
{
    node *pNew,*pTemp;
    int cnt=0;
    Head=NULL;
    pNew=pTemp=(node *)malloc(sizeof(node));
    if (!pNew)
        exit(0);

    while(cnt < n)
    {
        if(cnt==0)
        {
            scanf("%s %d",pNew->cNum,&pNew->score);
            pNew->pNext=NULL;
            //pTemp=pNew;
            Head=pTemp;
            cnt++;
        }
        else
        {
            pNew=(node *)malloc(sizeof(node));
            scanf("%s %d",pNew->cNum,&pNew->score);
            pNew->pNext=NULL;
            pTemp->pNext=pNew;
            pTemp=pNew;
            cnt++;
        }
    }

    return Head;
}
//合并链表
node* Combinelist(node* Head1,node* Head2)
{

    node* Head=Head1;
    while(Head1->pNext != NULL)
    {
        Head1=Head1->pNext;
    }
    Head1->pNext=Head2;

    return Head;

    /*
    node* Head=Head1;
    node* pTemp=(node *)malloc(sizeof(node));
    while(Head1!=NULL)
    {
        pTemp=Head1;
        Head1=Head1->pNext;
    }
    pTemp->pNext=Head2;
    free(Head1);
    return Head;
    */
}
//排序链表
node* sort(node* Head,int n,int m)
{

    int i,j;
    int cnt=n+m;
    node* pTemp;
    char Tempnum[30];
    int Tempscore;
    node * Newhead=Head;
    pTemp=(node *)malloc(sizeof(node));
    for(i=0;i<cnt-1;i++)
    {
        for(j=0;j<cnt-1-i;j++)
        {
            pTemp=Head;
            Head=Head->pNext;
            if(strcmp(pTemp->cNum,Head->cNum)>0)
            {
                strcpy(Tempnum,Head->cNum);
                Tempscore=Head->score;

                strcpy(Head->cNum,pTemp->cNum);
                Head->score=pTemp->score;

                strcpy(pTemp->cNum,Tempnum);
                pTemp->score=Tempscore;

            }

        }
        Head=Newhead;
    }

    return Newhead;

}
//输出链表
node* Printlist(node* Head)
{

    node * Newhead=Head;
    while(Head!=NULL)
    {
        printf("%s %d\n",Head->cNum,Head->score);
        Head=Head->pNext;
    }
    return Newhead;
}
int main()
{
    node *Head1=NULL;
    node *Head2=NULL;
    node *Head=NULL;
    int N,M;
    scanf("%d %d",&N,&M);
    //getchar();
    Head1=Createlist(Head1,N);
    Printlist(Head1);
    Head2=Createlist(Head2,M);
    Printlist(Head2);
    Head=Combinelist(Head1,Head2);
    Head=sort(Head,N,M);
    Printlist(Head);
    return 0;
}

供参考～

楼主的合并有问题～

[遇见女神]

引用 8 楼 你的小小栗子 的回复：

[quote=引用 3 楼 遇见女神的回复:]学号用整数类型保存而不是char数组

用字符数组也可以吧，我感觉和这个没啥关系[/quote]就是跟这个有关系。比如“2”分别和“1”、“10”比较，结果如何你自己运行看看。

[你的小小栗子]

引用 10 楼 遇见女神的回复:

[quote=引用 8 楼 你的小小栗子 的回复：][quote=引用 3 楼 遇见女神的回复:]学号用整数类型保存而不是char数组

用字符数组也可以吧，我感觉和这个没啥关系[/quote]就是跟这个有关系。比如“2”分别和“1”、“10”比较，结果如何你自己运行看看。[/quote] 收到，我试一下

[你的小小栗子]

引用 9 楼 自信男孩的回复:

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

typedef struct Node
{
    char cNum[30];
    int score;
    struct Node *pNext;
}node;

//创建链表
node*  Createlist(node *Head,int n)
{
    node *pNew,*pTemp;
    int cnt=0;
    Head=NULL;
    pNew=pTemp=(node *)malloc(sizeof(node));
    if (!pNew)
        exit(0);

    while(cnt < n)
    {
        if(cnt==0)
        {
            scanf("%s %d",pNew->cNum,&pNew->score);
            pNew->pNext=NULL;
            //pTemp=pNew;
            Head=pTemp;
            cnt++;
        }
        else
        {
            pNew=(node *)malloc(sizeof(node));
            scanf("%s %d",pNew->cNum,&pNew->score);
            pNew->pNext=NULL;
            pTemp->pNext=pNew;
            pTemp=pNew;
            cnt++;
        }
    }

    return Head;
}
//合并链表
node* Combinelist(node* Head1,node* Head2)
{

    node* Head=Head1;
    while(Head1->pNext != NULL)
    {
        Head1=Head1->pNext;
    }
    Head1->pNext=Head2;

    return Head;

    /*
    node* Head=Head1;
    node* pTemp=(node *)malloc(sizeof(node));
    while(Head1!=NULL)
    {
        pTemp=Head1;
        Head1=Head1->pNext;
    }
    pTemp->pNext=Head2;
    free(Head1);
    return Head;
    */
}
//排序链表
node* sort(node* Head,int n,int m)
{

    int i,j;
    int cnt=n+m;
    node* pTemp;
    char Tempnum[30];
    int Tempscore;
    node * Newhead=Head;
    pTemp=(node *)malloc(sizeof(node));
    for(i=0;i<cnt-1;i++)
    {
        for(j=0;j<cnt-1-i;j++)
        {
            pTemp=Head;
            Head=Head->pNext;
            if(strcmp(pTemp->cNum,Head->cNum)>0)
            {
                strcpy(Tempnum,Head->cNum);
                Tempscore=Head->score;

                strcpy(Head->cNum,pTemp->cNum);
                Head->score=pTemp->score;

                strcpy(pTemp->cNum,Tempnum);
                pTemp->score=Tempscore;

            }

        }
        Head=Newhead;
    }

    return Newhead;

}
//输出链表
node* Printlist(node* Head)
{

    node * Newhead=Head;
    while(Head!=NULL)
    {
        printf("%s %d\n",Head->cNum,Head->score);
        Head=Head->pNext;
    }
    return Newhead;
}
int main()
{
    node *Head1=NULL;
    node *Head2=NULL;
    node *Head=NULL;
    int N,M;
    scanf("%d %d",&N,&M);
    //getchar();
    Head1=Createlist(Head1,N);
    Printlist(Head1);
    Head2=Createlist(Head2,M);
    Printlist(Head2);
    Head=Combinelist(Head1,Head2);
    Head=sort(Head,N,M);
    Printlist(Head);
    return 0;
}

供参考～

楼主的合并有问题～

合并没有问题，之前我也是像你那样写的，但是输了0 0会出现指针异常，就是没有考虑到空链表的情况，可能是创建链表写的不够好，所以修改成我现在写的那样，防止了空链表异常的情况，找到测试不通过的问题了，是学号不能数组

[你的小小栗子]

感谢各位，发现是学号问题，刚刚看了测试是这个原因

[自信男孩]

引用 12 楼 你的小小栗子 的回复:

[quote=引用 9 楼 自信男孩的回复:]

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

typedef struct Node
{
    char cNum[30];
    int score;
    struct Node *pNext;
}node;

//创建链表
node*  Createlist(node *Head,int n)
{
    node *pNew,*pTemp;
    int cnt=0;
    Head=NULL;
    pNew=pTemp=(node *)malloc(sizeof(node));
    if (!pNew)
        exit(0);

    while(cnt < n)
    {
        if(cnt==0)
        {
            scanf("%s %d",pNew->cNum,&pNew->score);
            pNew->pNext=NULL;
            //pTemp=pNew;
            Head=pTemp;
            cnt++;
        }
        else
        {
            pNew=(node *)malloc(sizeof(node));
            scanf("%s %d",pNew->cNum,&pNew->score);
            pNew->pNext=NULL;
            pTemp->pNext=pNew;
            pTemp=pNew;
            cnt++;
        }
    }

    return Head;
}
//合并链表
node* Combinelist(node* Head1,node* Head2)
{

    node* Head=Head1;
    while(Head1->pNext != NULL)
    {
        Head1=Head1->pNext;
    }
    Head1->pNext=Head2;

    return Head;

    /*
    node* Head=Head1;
    node* pTemp=(node *)malloc(sizeof(node));
    while(Head1!=NULL)
    {
        pTemp=Head1;
        Head1=Head1->pNext;
    }
    pTemp->pNext=Head2;
    free(Head1);
    return Head;
    */
}
//排序链表
node* sort(node* Head,int n,int m)
{

    int i,j;
    int cnt=n+m;
    node* pTemp;
    char Tempnum[30];
    int Tempscore;
    node * Newhead=Head;
    pTemp=(node *)malloc(sizeof(node));
    for(i=0;i<cnt-1;i++)
    {
        for(j=0;j<cnt-1-i;j++)
        {
            pTemp=Head;
            Head=Head->pNext;
            if(strcmp(pTemp->cNum,Head->cNum)>0)
            {
                strcpy(Tempnum,Head->cNum);
                Tempscore=Head->score;

                strcpy(Head->cNum,pTemp->cNum);
                Head->score=pTemp->score;

                strcpy(pTemp->cNum,Tempnum);
                pTemp->score=Tempscore;

            }

        }
        Head=Newhead;
    }

    return Newhead;

}
//输出链表
node* Printlist(node* Head)
{

    node * Newhead=Head;
    while(Head!=NULL)
    {
        printf("%s %d\n",Head->cNum,Head->score);
        Head=Head->pNext;
    }
    return Newhead;
}
int main()
{
    node *Head1=NULL;
    node *Head2=NULL;
    node *Head=NULL;
    int N,M;
    scanf("%d %d",&N,&M);
    //getchar();
    Head1=Createlist(Head1,N);
    Printlist(Head1);
    Head2=Createlist(Head2,M);
    Printlist(Head2);
    Head=Combinelist(Head1,Head2);
    Head=sort(Head,N,M);
    Printlist(Head);
    return 0;
}

供参考～

楼主的合并有问题～

合并没有问题，之前我也是像你那样写的，但是输了0 0会出现指针异常，就是没有考虑到空链表的情况，可能是创建链表写的不够好，所以修改成我现在写的那样，防止了空链表异常的情况，找到测试不通过的问题了，是学号不能数组[/quote]

没问题吗？那你的pTemp申请的空间哪去了？还能找到吗？
你的循环里pTemp = Head1；这句已经把申请的空间地址覆盖了，还能找到吗？后面free(Head1);那么Head1是刚才申请的空间吗？不要以为测试没问题，就没问题。从逻辑上分析一下，看看会不会有问题。
另外，你的合并就是链表1的尾部接上链表2的头嘛，找到尾部，接上头部就好了。

[自信男孩]

引用 6 楼 qiu_shaofeng 的回复:

if(strcmp(pTemp->cNum,Head->cNum)>0) 比较不出学号大小

楼主的学号用的字符串，字符串大小的比较不就是用strcmp吗？
另外'1' < '2'这不是正确的吗？

[自信男孩]

引用 15 楼 自信男孩 的回复:

[quote=引用 6 楼 qiu_shaofeng 的回复:]if(strcmp(pTemp->cNum,Head->cNum)>0) 比较不出学号大小

楼主的学号用的字符串，字符串大小的比较不就是用strcmp吗？
另外'1' < '2'这不是正确的吗？[/quote]
对于两位数的确实是"10" < "2"

[你的小小栗子]

但是输入0 0后，调试打断点到合并链表的while判断会显示指针异常，请问下这样应该怎么改呢？

[你的小小栗子]

引用 14 楼 自信男孩的回复:

[quote=引用 12 楼 你的小小栗子 的回复:][quote=引用 9 楼 自信男孩的回复:]

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

typedef struct Node
{
    char cNum[30];
    int score;
    struct Node *pNext;
}node;

//创建链表
node*  Createlist(node *Head,int n)
{
    node *pNew,*pTemp;
    int cnt=0;
    Head=NULL;
    pNew=pTemp=(node *)malloc(sizeof(node));
    if (!pNew)
        exit(0);

    while(cnt < n)
    {
        if(cnt==0)
        {
            scanf("%s %d",pNew->cNum,&pNew->score);
            pNew->pNext=NULL;
            //pTemp=pNew;
            Head=pTemp;
            cnt++;
        }
        else
        {
            pNew=(node *)malloc(sizeof(node));
            scanf("%s %d",pNew->cNum,&pNew->score);
            pNew->pNext=NULL;
            pTemp->pNext=pNew;
            pTemp=pNew;
            cnt++;
        }
    }

    return Head;
}
//合并链表
node* Combinelist(node* Head1,node* Head2)
{

    node* Head=Head1;
    while(Head1->pNext != NULL)
    {
        Head1=Head1->pNext;
    }
    Head1->pNext=Head2;

    return Head;

    /*
    node* Head=Head1;
    node* pTemp=(node *)malloc(sizeof(node));
    while(Head1!=NULL)
    {
        pTemp=Head1;
        Head1=Head1->pNext;
    }
    pTemp->pNext=Head2;
    free(Head1);
    return Head;
    */
}
//排序链表
node* sort(node* Head,int n,int m)
{

    int i,j;
    int cnt=n+m;
    node* pTemp;
    char Tempnum[30];
    int Tempscore;
    node * Newhead=Head;
    pTemp=(node *)malloc(sizeof(node));
    for(i=0;i<cnt-1;i++)
    {
        for(j=0;j<cnt-1-i;j++)
        {
            pTemp=Head;
            Head=Head->pNext;
            if(strcmp(pTemp->cNum,Head->cNum)>0)
            {
                strcpy(Tempnum,Head->cNum);
                Tempscore=Head->score;

                strcpy(Head->cNum,pTemp->cNum);
                Head->score=pTemp->score;

                strcpy(pTemp->cNum,Tempnum);
                pTemp->score=Tempscore;

            }

        }
        Head=Newhead;
    }

    return Newhead;

}
//输出链表
node* Printlist(node* Head)
{

    node * Newhead=Head;
    while(Head!=NULL)
    {
        printf("%s %d\n",Head->cNum,Head->score);
        Head=Head->pNext;
    }
    return Newhead;
}
int main()
{
    node *Head1=NULL;
    node *Head2=NULL;
    node *Head=NULL;
    int N,M;
    scanf("%d %d",&N,&M);
    //getchar();
    Head1=Createlist(Head1,N);
    Printlist(Head1);
    Head2=Createlist(Head2,M);
    Printlist(Head2);
    Head=Combinelist(Head1,Head2);
    Head=sort(Head,N,M);
    Printlist(Head);
    return 0;
}

供参考～

楼主的合并有问题～

合并没有问题，之前我也是像你那样写的，但是输了0 0会出现指针异常，就是没有考虑到空链表的情况，可能是创建链表写的不够好，所以修改成我现在写的那样，防止了空链表异常的情况，找到测试不通过的问题了，是学号不能数组[/quote]

没问题吗？那你的pTemp申请的空间哪去了？还能找到吗？
你的循环里pTemp = Head1；这句已经把申请的空间地址覆盖了，还能找到吗？后面free(Head1);那么Head1是刚才申请的空间吗？不要以为测试没问题，就没问题。从逻辑上分析一下，看看会不会有问题。
另外，你的合并就是链表1的尾部接上链表2的头嘛，找到尾部，接上头部就好了。

[/quote] 但是输入0 0后，调试打断点到合并链表的while判断会显示指针异常，请问下这样应该怎么改呢？

[自信男孩]

建议楼主的学号直接用long类型，用char *反而比较复杂～

引用 18 楼 你的小小栗子 的回复:

[quote=引用 14 楼 自信男孩的回复:][quote=引用 12 楼 你的小小栗子 的回复:][quote=引用 9 楼 自信男孩的回复:]

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

typedef struct Node
{
    char cNum[30];
    int score;
    struct Node *pNext;
}node;

//创建链表
node*  Createlist(node *Head,int n)
{
    node *pNew,*pTemp;
    int cnt=0;
    Head=NULL;
    pNew=pTemp=(node *)malloc(sizeof(node));
    if (!pNew)
        exit(0);

    while(cnt < n)
    {
        if(cnt==0)
        {
            scanf("%s %d",pNew->cNum,&pNew->score);
            pNew->pNext=NULL;
            //pTemp=pNew;
            Head=pTemp;
            cnt++;
        }
        else
        {
            pNew=(node *)malloc(sizeof(node));
            scanf("%s %d",pNew->cNum,&pNew->score);
            pNew->pNext=NULL;
            pTemp->pNext=pNew;
            pTemp=pNew;
            cnt++;
        }
    }

    return Head;
}
//合并链表
node* Combinelist(node* Head1,node* Head2)
{

    node* Head=Head1;
    while(Head1->pNext != NULL)
    {
        Head1=Head1->pNext;
    }
    Head1->pNext=Head2;

    return Head;

    /*
    node* Head=Head1;
    node* pTemp=(node *)malloc(sizeof(node));
    while(Head1!=NULL)
    {
        pTemp=Head1;
        Head1=Head1->pNext;
    }
    pTemp->pNext=Head2;
    free(Head1);
    return Head;
    */
}
//排序链表
node* sort(node* Head,int n,int m)
{

    int i,j;
    int cnt=n+m;
    node* pTemp;
    char Tempnum[30];
    int Tempscore;
    node * Newhead=Head;
    pTemp=(node *)malloc(sizeof(node));
    for(i=0;i<cnt-1;i++)
    {
        for(j=0;j<cnt-1-i;j++)
        {
            pTemp=Head;
            Head=Head->pNext;
            if(strcmp(pTemp->cNum,Head->cNum)>0)
            {
                strcpy(Tempnum,Head->cNum);
                Tempscore=Head->score;

                strcpy(Head->cNum,pTemp->cNum);
                Head->score=pTemp->score;

                strcpy(pTemp->cNum,Tempnum);
                pTemp->score=Tempscore;

            }

        }
        Head=Newhead;
    }

    return Newhead;

}
//输出链表
node* Printlist(node* Head)
{

    node * Newhead=Head;
    while(Head!=NULL)
    {
        printf("%s %d\n",Head->cNum,Head->score);
        Head=Head->pNext;
    }
    return Newhead;
}
int main()
{
    node *Head1=NULL;
    node *Head2=NULL;
    node *Head=NULL;
    int N,M;
    scanf("%d %d",&N,&M);
    //getchar();
    Head1=Createlist(Head1,N);
    Printlist(Head1);
    Head2=Createlist(Head2,M);
    Printlist(Head2);
    Head=Combinelist(Head1,Head2);
    Head=sort(Head,N,M);
    Printlist(Head);
    return 0;
}

供参考～

楼主的合并有问题～

合并没有问题，之前我也是像你那样写的，但是输了0 0会出现指针异常，就是没有考虑到空链表的情况，可能是创建链表写的不够好，所以修改成我现在写的那样，防止了空链表异常的情况，找到测试不通过的问题了，是学号不能数组[/quote]

没问题吗？那你的pTemp申请的空间哪去了？还能找到吗？
你的循环里pTemp = Head1；这句已经把申请的空间地址覆盖了，还能找到吗？后面free(Head1);那么Head1是刚才申请的空间吗？不要以为测试没问题，就没问题。从逻辑上分析一下，看看会不会有问题。
另外，你的合并就是链表1的尾部接上链表2的头嘛，找到尾部，接上头部就好了。

[/quote]
但是输入0 0后，调试打断点到合并链表的while判断会显示指针异常，请问下这样应该怎么改呢？[/quote]
合并函数里，不会对输入的数值判断呀，我说的是合并函数，修改的也是合并函数即：Combinelist

[你的小小栗子]

引用 19 楼 自信男孩的回复:

建议楼主的学号直接用long类型，用char *反而比较复杂～

[quote=引用 18 楼 你的小小栗子 的回复:][quote=引用 14 楼 自信男孩的回复:][quote=引用 12 楼 你的小小栗子 的回复:][quote=引用 9 楼 自信男孩的回复:]

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

typedef struct Node
{
    char cNum[30];
    int score;
    struct Node *pNext;
}node;

//创建链表
node*  Createlist(node *Head,int n)
{
    node *pNew,*pTemp;
    int cnt=0;
    Head=NULL;
    pNew=pTemp=(node *)malloc(sizeof(node));
    if (!pNew)
        exit(0);

    while(cnt < n)
    {
        if(cnt==0)
        {
            scanf("%s %d",pNew->cNum,&pNew->score);
            pNew->pNext=NULL;
            //pTemp=pNew;
            Head=pTemp;
            cnt++;
        }
        else
        {
            pNew=(node *)malloc(sizeof(node));
            scanf("%s %d",pNew->cNum,&pNew->score);
            pNew->pNext=NULL;
            pTemp->pNext=pNew;
            pTemp=pNew;
            cnt++;
        }
    }

    return Head;
}
//合并链表
node* Combinelist(node* Head1,node* Head2)
{

    node* Head=Head1;
    while(Head1->pNext != NULL)
    {
        Head1=Head1->pNext;
    }
    Head1->pNext=Head2;

    return Head;

    /*
    node* Head=Head1;
    node* pTemp=(node *)malloc(sizeof(node));
    while(Head1!=NULL)
    {
        pTemp=Head1;
        Head1=Head1->pNext;
    }
    pTemp->pNext=Head2;
    free(Head1);
    return Head;
    */
}
//排序链表
node* sort(node* Head,int n,int m)
{

    int i,j;
    int cnt=n+m;
    node* pTemp;
    char Tempnum[30];
    int Tempscore;
    node * Newhead=Head;
    pTemp=(node *)malloc(sizeof(node));
    for(i=0;i<cnt-1;i++)
    {
        for(j=0;j<cnt-1-i;j++)
        {
            pTemp=Head;
            Head=Head->pNext;
            if(strcmp(pTemp->cNum,Head->cNum)>0)
            {
                strcpy(Tempnum,Head->cNum);
                Tempscore=Head->score;

                strcpy(Head->cNum,pTemp->cNum);
                Head->score=pTemp->score;

                strcpy(pTemp->cNum,Tempnum);
                pTemp->score=Tempscore;

            }

        }
        Head=Newhead;
    }

    return Newhead;

}
//输出链表
node* Printlist(node* Head)
{

    node * Newhead=Head;
    while(Head!=NULL)
    {
        printf("%s %d\n",Head->cNum,Head->score);
        Head=Head->pNext;
    }
    return Newhead;
}
int main()
{
    node *Head1=NULL;
    node *Head2=NULL;
    node *Head=NULL;
    int N,M;
    scanf("%d %d",&N,&M);
    //getchar();
    Head1=Createlist(Head1,N);
    Printlist(Head1);
    Head2=Createlist(Head2,M);
    Printlist(Head2);
    Head=Combinelist(Head1,Head2);
    Head=sort(Head,N,M);
    Printlist(Head);
    return 0;
}

供参考～

楼主的合并有问题～

合并没有问题，之前我也是像你那样写的，但是输了0 0会出现指针异常，就是没有考虑到空链表的情况，可能是创建链表写的不够好，所以修改成我现在写的那样，防止了空链表异常的情况，找到测试不通过的问题了，是学号不能数组[/quote]

没问题吗？那你的pTemp申请的空间哪去了？还能找到吗？
你的循环里pTemp = Head1；这句已经把申请的空间地址覆盖了，还能找到吗？后面free(Head1);那么Head1是刚才申请的空间吗？不要以为测试没问题，就没问题。从逻辑上分析一下，看看会不会有问题。
另外，你的合并就是链表1的尾部接上链表2的头嘛，找到尾部，接上头部就好了。

[/quote]
但是输入0 0后，调试打断点到合并链表的while判断会显示指针异常，请问下这样应该怎么改呢？[/quote]
合并函数里，不会对输入的数值判断呀，我说的是合并函数，修改的也是合并函数即：Combinelist[/quote] 好的，谢谢兄弟，这个问题我想了很久。