为什么我写的con( )函数第二次调用就会死循环，第一次却没事？

谁能帮忙看看为什么我写的con( )函数第二次调用就会死循环？第二次运行的过程中卡死在sort( )函数中的while语句中：

Lnode* sort(Lnode* L)    
{
    Lnode *tail, *ml, *m, *q;
    m = L;
    if (m != NULL){
        while (m->next != NULL)      //逐句检查的时候，发现第二次调用con(  )时，
            m = m->next;                //con(  )运行到sort函数时一直卡在这两句循环，但是第一次调用con( )却不会这样
    }

以下是全代码（一元稀疏多项式计算器）

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

typedef struct node
{
    float c;    //系数
    int e;        //指数
    int n;        //项数
    struct node* next;
}Lnode;

Lnode* creat(int n)
{
    Lnode* L;
    Lnode* tail;
    tail = L = NULL;
    for (int i = 0; i < n; i++) {    //尾插法记录多项式数据
        Lnode* p;
        p = (Lnode*)malloc(sizeof(Lnode));
        p->next = NULL;
        printf("请分别输入第%d项的系数和指数:", i + 1);
        scanf("%f %d", &p->c, &p->e);
        if (i == 0) {
            L = p;
            tail = p;
        }
        else {
            tail->next = p;
            tail = p;
        }
    }
    L->n = n;
    Lnode* sort(Lnode * L);
    sort(L);
    return L;
}
void swap(Lnode* p,Lnode* q)    //交换操作
{
    float temp_c;
    int temp_e;
    temp_c = p->c; p->c = q->c; q->c = temp_c;
    temp_e = p->e; p->e = q->e; q->e = temp_e;
}
Lnode* sort(Lnode* L)        //降序冒泡排序
{
    Lnode *tail, *ml, *m, *q;
    m = L;
    if (m != NULL){
        while (m->next != NULL)
            m = m->next;
    }
    tail = m;
    while (tail != L){ 
        ml = L;        //ml指向最后一次交换的位置
        for (m = L; m != tail; m = m->next){
            q = m->next;
            if (m->e < q->e){
                swap(m, q);
                ml = m;
            }
        }
        tail = ml;
    }
    return m;
}

void disp(Lnode* L,int n)
{
    Lnode* p;
    p = L;
    if (p == NULL)
        printf("0\n\n");
    else{
        while (p != NULL) {
            printf("%.2fX^%d ", p->c, p->e);
            if (p->next != NULL) {
                if ((p->next)->c >= 0)
                    printf("+");
            }
            p = p->next;
        }
        printf("\n");
        p = L;
        printf("序列形式：(%d, ", n);
        while (p != NULL) {
            printf("%.2f,%d", p->c, p->e);
            if (p->next != NULL)
                printf(", ");
            p = p->next;
        }
        printf(")");
        printf("\n\n");
    }
}
void calculate(Lnode* L)
{
    Lnode* p = L;
    int x;
    double sum = 0;
    printf("请输入X的值：");
    scanf("%d", &x);
    while (p != NULL)
    {
        sum += p->c * pow(x, p->e);
        p = p->next;
    }
    printf("当X的值为%d时，多项式的值为：%.2f\n\n", x, sum);
}
Lnode* con(Lnode* a, Lnode* b, int m)    //多项式a、b求和差
{
    Lnode* p, * q, *tail;
    p = a;  q = b;  tail = p; 
    if (m == 4) {
        Lnode* qi = q;
        while (qi != NULL) {
            qi->c = -qi->c;
            qi = qi->next;
        }
    }
    if (p != NULL) {
        while (tail->next != NULL)
            tail = tail->next;
        tail->next = q;
        p = sort(p);
        p->n += q->n;
    }
    if (p == NULL && q != NULL)
        p = q;
    tail = p;
    while (tail != NULL){        //合并同类项
        if(tail->next != NULL){
            if (tail->e == (tail->next)->e) {
                Lnode* r = tail->next;
                tail->c += r->c;
                tail->next = r->next;
                free(r);
                p->n -= 1;
            }
        }
        tail = tail->next;
    }
    return p;
    free(p);
}
void select(Lnode* a, Lnode* b)
{
    Lnode* c = NULL; Lnode* d = NULL;
    int m;
    printf("请输入数字指令：(0:退出计算器  1:计算a在X处的值  2:计算b在X处的值  3:求a+b  4:求a-b  5:计算a+b在X处的值  6:计算a-b在X处的值)\n");
    scanf("%d",&m);
    while (m != 0){
        switch (m) {
        case 1:
            calculate(a);
            printf("请输入下一个数字指令...\n");
            scanf("%d", &m);
            break;
        case 2:
            calculate(b);
            printf("请输入下一个数字指令...\n");
            scanf("%d", &m);
            break;
        case 3:
            c = con(a, b, 3);
            printf("\n多项式 a+b = ");
            disp(c, c->n);
            //free(c);
            printf("请输入下一个数字指令...\n");
            scanf("%d", &m);
            break;
        case 4:
            d = con(a, b, 4);
            printf("\n多项式 a-b = ");
            disp(d, d->n);
            printf("请输入下一个数字指令...\n");
            scanf("%d", &m);
            break;
        case 5:
            if (c == NULL){
                c = con(a, b, 3);
                printf("\n多项式 a+b = ");
                disp(c, c->n);
            }
            calculate(c);
            printf("请输入下一个数字指令...\n");
            scanf("%d", &m);
            break;
        case 6:
            if (d == NULL){
                d = con(a, b, 4);
                printf("\n多项式 a+b = ");
                disp(d, d->n);
            }
            calculate(c);
            printf("请输入下一个数字指令...\n");
            scanf("%d", &m);
            break;
        default: printf("请输入正确的数字指令！\n"); break;
        }
    }
}

int main()
{
    Lnode* a, * b; Lnode *c = NULL; Lnode* d;
    int n1;
    printf("请输入多项式a的项数: ");
    scanf("%d", &n1);
    a = creat(n1);
    printf("\n多项式 a = ");
    disp(a,n1);

    int n2;
    printf("请输入多项式b的项数: ");
    scanf("%d", &n2);
    b = creat(n2);
    printf("\n多项式 b = ");
    disp(b, n2);

    c = con(a, b, 3);
    printf("\n多项式 a+b = ");
    disp(c, c->n);

    d = con(a, b, 4);
    printf("\n多项式 a-b = ");
    disp(d, d->n);

    //select(a, b);
    return 0;
}

TechWhizKid参考GPT回答：

• 当你执行 tail->next = q; 时，你将链表 a 的尾部连接到链表 b 的头部，而如果你在第二次调用 con() 函数时再次这样做，那么链表 a 的尾部就会再次连接到链表 b 的头部，形成了一个循环引用，也就是链表 a 和 b 共享了一部分节点。
• 解决这个问题的一个方式是在调用 con() 函数时创建链表 a 和 b 的副本，这样就不会修改原始链表。另一个解决方案是在调用 con() 函数后不再使用原始链表，因为 con() 函数已经修改了它们。
• con()函数在处理完两个链表后，会对这两个链表造成改变。在调用con()函数后，链表 a 和 b 不再是两个独立的链表，而是连接在一起的。这就是为什么第二次调用con()函数时，你会发现一个死循环的问题，因为你实际上已经改变了这两个链表的结构。
• 下面将给出一种可能的解决方法，即在con()函数中创建链表 a 和 b 的副本，这样就可以对副本进行修改，而不会影响到原始的链表 a 和 b。

修改的con()函数如下：

Lnode* con(Lnode* a, Lnode* b, int m)    //多项式a、b求和差
{
    Lnode* p, * q, *tail, *new_a, *new_b, *new_tail;
    
    // 创建 a 的副本
    new_a = NULL;
    new_tail = NULL;
    for(p = a; p != NULL; p = p->next) {
        Lnode* new_node = (Lnode*)malloc(sizeof(Lnode));
        new_node->c = p->c;
        new_node->e = p->e;
        new_node->next = NULL;
        if(new_a == NULL) {
            new_a = new_node;
            new_tail = new_node;
        } else {
            new_tail->next = new_node;
            new_tail = new_node;
        }
    }

    // 创建 b 的副本
    new_b = NULL;
    new_tail = NULL;
    for(p = b; p != NULL; p = p->next) {
        Lnode* new_node = (Lnode*)malloc(sizeof(Lnode));
        new_node->c = p->c;
        new_node->e = p->e;
        new_node->next = NULL;
        if(new_b == NULL) {
            new_b = new_node;
            new_tail = new_node;
        } else {
            new_tail->next = new_node;
            new_tail = new_node;
        }
    }
    
    p = new_a;  
    q = new_b;  
    tail = p; 
    if (m == 4) {
        Lnode* qi = q;
        while (qi != NULL) {
            qi->c = -qi->c;
            qi = qi->next;
        }
    }
    if (p != NULL) {
        while (tail->next != NULL)
            tail = tail->next;
        tail->next = q;
        p = sort(p);
        p->n += q->n;
    }
    if (p == NULL && q != NULL)
        p = q;
    tail = p;
    while (tail != NULL){        //合并同类项
        if(tail->next != NULL){
            if (tail->e == (tail->next)->e) {
                Lnode* r = tail->next;
                tail->c += r->c;
                tail->next = r->next;
                free(r);
                p->n -= 1;
            }
        }
        tail = tail->next;
    }
    return p;
}

在这个修改过的con()函数中，先创建了链表 a 和 b 的副本，然后在副本上进行所有的操作，从而保留了原始链表的内容。这样第二次调用con()函数时，仍然用原始链表 a 和 b，因此不会出现死循环的问题。

这里创建了新的节点，所以你要确保在不再要这些节点的时候释放它们的内存。在C语言中，如果你分配了内存，但是没有释放它，那么就会导致内存泄漏，这可能会在你的程序运行一段时间后导致问题。你可以通过调用 free() 函数来释放你分配的内存。

不知道你这个问题是否已经解决, 如果还没有解决的话:

• 你可以参考下这个问题的回答, 看看是否对你有帮助, 链接: https://ask.csdn.net/questions/7750476
• 除此之外, 这篇博客: 试题 算法提高 成绩排序 （对结构体排序 sort函数）中的 试题 算法提高 成绩排序 部分也许能够解决你的问题, 你可以仔细阅读以下内容或者直接跳转源博客中阅读:
  
  提交此题  

  资源限制

  时间限制：1.0s   内存限制：256.0MB

  问题描述

  　　给出n个学生的成绩，将这些学生按成绩排序，
  　　排序规则，优先考虑数学成绩，高的在前；数学相同，英语高的在前；数学英语都相同，语文高的在前；三门都相同，学号小的在前

  输入格式

  　　第一行一个正整数n，表示学生人数
  　　接下来n行每行3个0~100的整数，第i行表示学号为i的学生的数学、英语、语文成绩

  输出格式

  　　输出n行，每行表示一个学生的数学成绩、英语成绩、语文成绩、学号
  　　按排序后的顺序输出

  样例输入

  2
  1 2 3
  2 3 4

  样例输出

  2 3 4 2
  1 2 3 1

  #include <iostream>
  #include<algorithm>
  using namespace std;
  struct achievement
  {
  	int math;
  	int chinese;
  	int english;
  	int id;
  };
  	bool cmp(const achievement &s1,const achievement &s2) //sort函数第三变量排序方法
  		{
  			if (s1.math==s2.math)
  				{
  					if(s1.english==s2.english)
  						{
  							if(s1.chinese==s2.chinese)
  							{
  								return s1.id<s2.id;
  							}
  							else return s1.chinese>s2.chinese;
  						}
  					else return s1.english>s2.english;
  				}
  			else return s1.math>s2.math;
  		}
  int main()
  {
  	int n;
  	cin>>n;
  	achievement *student=new achievement [n+1];
  	for(int i=1;i<=n;i++)
  		{
  			cin>>student[i].math>>student[i].english>>student[i].chinese;
  			student[i].id=i;
  		}	
  	sort(student+1,student+n+1,cmp);
  	for(int i=1;i<=n;i++)
  	{
  		cout<<student[i].math<<' '<<student[i].english<<' '<<student[i].chinese<<' '<<student[i].id<<endl;
  	}
  }

  备注：ends 与 ' '不同 

  sort函数排序

  头文件#include<algorithm>

  sort函数三个参数，前两个为排序的起始地址和终止地址（左闭右开），第三个参数为排序类型，不填默认为升序。

  #include<algorithm>
  struct A
  {   
      int a;
  }
  bool cmp (A a1,A a2)
  { return a1.a<a2.a }//将A结构体升序排列
  bool cmp (A a1,A a2)
  { return a1.a>a2.a }//将A结构体降序排列
  sort(begin,end,cmp)

   

• 以下回答来自chatgpt:

  该问题由于没有提供con()函数的代码，无法进行具体分析和解决。请提供完整的代码后再进行分析。

  参考资料中提供了一个关于成绩排序的问题和代码示例。如果有成绩排序相关问题，可以参考该代码进行解决。

如果你已经解决了该问题, 非常希望你能够分享一下解决方案, 写成博客, 将相关链接放在评论区, 以帮助更多的人 ^-^

con( )函数里，对链表 a b 的处理操作，要把握不能对原链表有改变，不然就会出现第二次调用con()函数时出错的问题，因为原链表 a b 的结点结构已经被改变了。