编写一个程序用单链表存储多项式，并实现两个一元多项式a与b相加的函数。a，b刚开始是无序的，a与b之和按降序排列。例如：\n 多项式a: 1.2x^0

### 回答1：
这道题需要编写一个程序，使用单链表存储多项式，并实现两个一元多项式a、b相加的函数。a、b的系数和指数分别从键盘输入，且a、b是无序的，按降序排列。例如：

多项式a: 3x^4+2x^2+x^0
多项式b: 4x^5+1x^4+3x^0
相加结果：4x^5+4x^4+2x^2+4x^0

具体实现流程为：先定义一个多项式结构体，包含系数coef和指数exp两个属性，并定义单链表节点类型。然后定义一个创建多项式节点的函数createPolyNode，以及向链表中插入一个多项式节点的函数insertPolyNode。接着定义一个按照指数降序排列的函数sortPolyList，使用冒泡排序实现。最后定义一个多项式相加的函数addPoly，并在main函数中进行调用。

### 回答2：
题目要求我们编写一个程序，用单链表存储多项式，并实现两个一元多项式a和b相加的函数。为了更好地理解和解答该问题，我们可以分成三个部分展开说明：

1. 单链表的实现

单链表是一种常见的线性数据结构，它由若干个节点组成，每个节点保存着一个数据元素和一个指针，指向它的后继节点。单链表在插入、删除操作时比较方便，但查找和访问操作的效率较低。

为了实现多项式的存储，我们可以利用单链表中每个节点存储项的系数、指数信息，并通过指针连接各节点。如下所示的结构体可以表示单链表中每一个节点的信息：

typedef struct PolyNode
{
double coef; // 存储项的系数
int expon; // 存储项的指数
struct PolyNode *next;
} PolyNode;

2. 多项式的存储和相加

多项式是由若干项组成的，项由系数和指数组成。在单链表中，我们可以将多项式按降幂次的顺序存储（前插法），保证多项式的实现更加便利和高效。

在实现多项式相加的函数时，我们需要将两个多项式的对应项相加，并将结果存入新的链表中。由于题目中要求结果按降序排列，我们需要在每次添加节点时找到正确的位置，并合并相同项。

下面是实现多项式相加的函数示意代码：

PolyNode* AddPoly(PolyNode *A, PolyNode *B)
{
PolyNode *head = new PolyNode;
PolyNode *tail = head;
PolyNode *pa = A->next, *pb = B->next;

while (pa && pb)
{
// 将对应项相加
if (pa->expon > pb->expon)
{
tail->next = new PolyNode{ pa->coef, pa->expon };
pa = pa->next;
}
else if (pa->expon < pb->expon)
{
tail->next = new PolyNode{ pb->coef, pb->expon };
pb = pb->next;
}
else
{
double sum = pa->coef + pb->coef;
if (sum != 0)
{
tail->next = new PolyNode{ sum, pa->expon };
}

pa = pa->next;
pb = pb->next;
}
// 将新节点添加到链表尾部
tail = tail->next;
}

// 将A或B多余的项添加到链表尾部
while (pa)
{
tail->next = new PolyNode{ pa->coef, pa->expon };
pa = pa->next;
tail = tail->next;
}

while (pb)
{
tail->next = new PolyNode{ pb->coef, pb->expon };
pb = pb->next;
tail = tail->next;
}

// 删除头节点，并按降序排列
PolyNode *temp = head;
head = head->next;
delete temp;
head = Reverse(head);

return head;
}

3. 多项式结果的降序排列

为了实现多项式结果的降序排列，我们可以利用快速排序算法对链表节点进行排序。以下是实现链表排序的示意代码：

PolyNode* Reverse(PolyNode *head)
{
PolyNode *p = head->next;
head->next = nullptr;

while (p)
{
PolyNode *temp = p->next;
p->next = head->next;
head->next = p;
p = temp;
}

return head;
}

总结：

通过以上分析，我们可以发现编写程序用单链表存储多项式，并实现两个一元多项式a与b相加的函数，需要我们对于单链表的实现、多项式的存储和相加以及链表排序等问题具有深入的理解和实现。我们还需要充分运用数据结构及算法知识，善于将理论转化为代码，尽可能优化算法实现效率，实现更加高效的程序算法解决问题，实践操作多项式相加问题。

### 回答3：
该程序需要实现单链表的建立，插入，删除和遍历功能，同时实现多项式相加和降序排列的功能。

首先需要定义一个单链表的结构体，包括多项式的系数和指数，以及指向下一个节点的指针。

typedef struct PolyNode
{
    float coef;  //系数
    int exp;     //指数
    struct PolyNode *next; //指向下一个节点的指针
} PolyNode, *Polynomial;

然后需要实现单链表的建立、插入、删除和遍历等操作。这里给出插入操作的示例代码：

void Insert(Polynomial *p, float coef, int exp)
{
    Polynomial q, s;
    q = *p;
    while (q->next && q->next->exp > exp)
    {
        q = q->next;
    }
    s = (Polynomial)malloc(sizeof(PolyNode));
    s->coef = coef;
    s->exp = exp;
    s->next = q->next;
    q->next = s;
}

接下来需要实现两个一元多项式相加的函数。先将两个多项式按指数降序排列，然后依次遍历两个多项式的节点，如果指数相同则系数相加，否则将指数较大的节点插入结果链表中。

void Add(Polynomial a, Polynomial b, Polynomial *c)
{
    *c = (Polynomial)malloc(sizeof(PolyNode));
    (*c)->next = NULL;
    Polynomial rear = *c, temp;
    a = a->next;
    b = b->next;

    while (a && b)
    {
        if (a->exp > b->exp)
        {
            temp = (Polynomial)malloc(sizeof(PolyNode));
            temp->coef = a->coef;
            temp->exp = a->exp;
            rear->next = temp;
            rear = temp;
            a = a->next;
        }
        else if (a->exp < b->exp)
        {
            temp = (Polynomial)malloc(sizeof(PolyNode));
            temp->coef = b->coef;
            temp->exp = b->exp;
            rear->next = temp;
            rear = temp;
            b = b->next;
        }
        else //指数相同，则系数相加
        {
            float sum = a->coef + b->coef;
            if (sum != 0)
            {
                temp = (Polynomial)malloc(sizeof(PolyNode));
                temp->coef = sum;
                temp->exp = a->exp;
                rear->next = temp;
                rear = temp;
            }
            a = a->next;
            b = b->next;
        }
    }
    while (a)
    {
        temp = (Polynomial)malloc(sizeof(PolyNode));
        temp->coef = a->coef;
        temp->exp = a->exp;
        rear->next = temp;
        rear = temp;
        a = a->next;
    }
    while (b)
    {
        temp = (Polynomial)malloc(sizeof(PolyNode));
        temp->coef = b->coef;
        temp->exp = b->exp;
        rear->next = temp;
        rear = temp;
        b = b->next;
    }
    rear->next = NULL;
    DeleteZero(c); //删除系数为0的项
}

void DeleteZero(Polynomial *p)
{
    Polynomial q, r;
    q = (*p)->next;
    r = *p;
    while (q)
    {
        if (q->coef == 0)
        {
            r->next = q->next;
            free(q);
            q = r->next;
        }
        else
        {
            r = q;
            q = q->next;
        }
    }
}

最后，将结果链表按指数降序排列输出即可。