一元多项式相加顺序表

一元多项式相加可以使用顺序表来实现。具体实现方法是将多项式的系数存储在顺序表的元素中，下标表示该元素对应的指数。相同指数的系数相加即可。

例如，多项式 P(x) = 3x^2 + 2x + 1 可以表示为顺序表 [1, 2, 3]，其中下标 0 对应的系数为 1，下标 1 对应的系数为 2，下标 2 对应的系数为 3。

两个多项式相加时，可以先将它们的顺序表按照指数从小到大排序，然后从头开始遍历两个顺序表，将相同指数的系数相加，不同指数的系数直接复制到结果顺序表中即可。

相关问题

顺序表一元多项式指数相加顺序表程序

以下是顺序表一元多项式指数相加的程序：

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

#define MAXSIZE 100

typedef struct {
    int coef;  // 系数
    int expn;  // 指数
} ElemType;

typedef struct {
    ElemType data[MAXSIZE];
    int length;
} SqList;

void InitList(SqList *L) {
    L->length = 0;
}

void CreateList(SqList *L) {
    printf("请输入多项式的项数：");
    scanf("%d", &L->length);
    printf("请按照指数递减的顺序输入多项式的系数和指数：\n");
    for (int i = 0; i < L->length; i++) {
        scanf("%d%d", &L->data[i].coef, &L->data[i].expn);
    }
}

void AddList(SqList *La, SqList *Lb, SqList *Lc) {
    int i = 0, j = 0, k = 0;
    while (i < La->length && j < Lb->length) {
        if (La->data[i].expn > Lb->data[j].expn) {
            Lc->data[k++] = La->data[i++];
        } else if (La->data[i].expn < Lb->data[j].expn) {
            Lc->data[k++] = Lb->data[j++];
        } else {
            int sum = La->data[i].coef + Lb->data[j].coef;
            if (sum != 0) {
                Lc->data[k].coef = sum;
                Lc->data[k++].expn = La->data[i].expn;
            }
            i++;
            j++;
        }
    }
    while (i < La->length) {
        Lc->data[k++] = La->data[i++];
    }
    while (j < Lb->length) {
        Lc->data[k++] = Lb->data[j++];
    }
    Lc->length = k;
}

void PrintList(SqList *L) {
    for (int i = 0; i < L->length; i++) {
        printf("%dx^%d", L->data[i].coef, L->data[i].expn);
        if (i != L->length - 1) {
            printf(" + ");
        }
    }
    printf("\n");
}

int main() {
    SqList La, Lb, Lc;
    InitList(&La);
    InitList(&Lb);
    InitList(&Lc);
    CreateList(&La);
    CreateList(&Lb);
    AddList(&La, &Lb, &Lc);
    printf("多项式A：");
    PrintList(&La);
    printf("多项式B：");
    PrintList(&Lb);
    printf("多项式C=A+B：");
    PrintList(&Lc);
    return 0;
}

一元多项式相加c语言

一元多项式相加是指将两个一元多项式相加得到一个新的一元多项式。在C语言中，可以使用单链表来实现一元多项式的存储和相加。具体实现步骤如下：

1. 定义一个结构体来表示一元多项式的每一项，包括系数和指数两个成员变量。

2. 定义一个单链表结构体来存储一元多项式，每个节点存储一项的系数和指数。

3. 编写函数来创建一元多项式，输入时逐项、按顺序输入一元多项式的系数、指数，输入系数为0时表述输入结束。

4. 编写函数来实现一元多项式相加，遍历两个链表，将相同指数的项相加，将结果存储在一个新的链表中。

5. 编写函数来输出一元多项式，遍历链表，按照指数从高到低的顺序输出每一项。

下面是一个简单的C语言实现示例：

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

// 定义一元多项式项的结构体
typedef struct PolyNode {
    int coef;  // 系数
    int expon; // 指数
    struct PolyNode *next;
} PolyNode, *Polynomial;

// 创建一元多项式
Polynomial createPoly() {
    Polynomial p, rear, t;
    int c, e;
    p = (PolyNode *)malloc(sizeof(PolyNode));
    p->next = NULL;
    rear = p;
    scanf("%d %d", &c, &e);
    while (c != 0) {
        t = (PolyNode *)malloc(sizeof(PolyNode));
        t->coef = c;
        t->expon = e;
        t->next = NULL;
        rear->next = t;
        rear = t;
        scanf("%d %d", &c, &e);
    }
    return p;
}

// 一元多项式相加
Polynomial addPoly(Polynomial p1, Polynomial p2) {
    Polynomial front, rear, temp;
    int sum;
    rear = (PolyNode *)malloc(sizeof(PolyNode));
    front = rear;
    while (p1 && p2) {
        if (p1->expon > p2->expon) {
            temp = (PolyNode *)malloc(sizeof(PolyNode));
            temp->coef = p1->coef;
            temp->expon = p1->expon;
            temp->next = NULL;
            rear->next = temp;
            rear = temp;
            p1 = p1->next;
        } else if (p1->expon < p2->expon) {
            temp = (PolyNode *)malloc(sizeof(PolyNode));
            temp->coef = p2->coef;
            temp->expon = p2->expon;
            temp->next = NULL;
            rear->next = temp;
            rear = temp;
            p2 = p2->next;
        } else {
            sum = p1->coef + p2->coef;
            if (sum != 0) {
                temp = (PolyNode *)malloc(sizeof(PolyNode));
                temp->coef = sum;
                temp->expon = p1->expon;
                temp->next = NULL;
                rear->next = temp;
                rear = temp;
            }
            p1 = p1->next;
            p2 = p2->next;
        }
    }
    while (p1) {
        temp = (PolyNode *)malloc(sizeof(PolyNode));
        temp->coef = p1->coef;
        temp->expon = p1->expon;
        temp->next = NULL;
        rear->next = temp;
        rear = temp;
        p1 = p1->next;
    }
    while (p2) {
        temp = (PolyNode *)malloc(sizeof(PolyNode));
        temp->coef = p2->coef;
        temp->expon = p2->expon;
        temp->next = NULL;
        rear->next = temp;
        rear = temp;
        p2 = p2->next;
    }
    rear->next = NULL;
    temp = front;
    front = front->next;
    free(temp);
    return front;
}

// 输出一元多项式
void printPoly(Polynomial p) {
    if (!p) {
        printf("0 0\n");
        return;
    }
    while (p) {
        printf("%d %d", p->coef, p->expon);
        p = p->next;
        if (p) {
            printf(" ");
        } else {
            printf("\n");
        }
    }
}

int main() {
    Polynomial p1, p2, p3;
    p1 = createPoly();
    p2 = createPoly();
    p3 = addPoly(p1, p2);
    printPoly(p3);
    return 0;
}