一元多项式的表示及相加、相减（链表、数组）

输入的一元多项式采用只输入各项的系数与指数这种简化的方式。如对于多项式2x^2+6x^5，输入为：
2 2
6 5

链表表示：

#include <stdio.h>
#include <stdlib.h>
#include<math.h>
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE -1  
#define OVERFLOW -2
typedef struct    
{
    float coef;   
    int expn;  
}term, ElemType;  
typedef struct LNode   
{
    ElemType data;
    struct LNode* next;
}LNode, * Link, * Position;
typedef struct  
{
    Link head, tail;
    int len;
}LinkList;
typedef LinkList polynomial; 
typedef int Status;
Status InitList(LinkList* L)
{
    Link p;
    p = (Link)malloc(sizeof(LNode)); 
    if (p)
    {
        p->next = NULL;
        (*L).head = (*L).tail = p;
        (*L).len = 0;
        return OK;
    }
    else
        return ERROR;
}
Status MakeNode(Link* p, ElemType e)
{ 
    (*p) = (Link)malloc(sizeof(LNode));  
    if (!(*p)) return ERROR;             
    (*p)->data = e;
    return OK;
}
Status InsFirst(LinkList* L, Link h, Link s)   
{
    s->next = h->next;
    h->next = s;
    if (h == (*L).tail)       
        (*L).tail = h->next; 
    (*L).len++;
    return OK;
}
Status DelFirst(LinkList* L, Link h, Link* q) 
{
    *q = h->next;
    if (*q)                    
    {
        h->next = (*q)->next;
        if (!h->next)          
            (*L).tail = h;   
        (*L).len--;
        return OK;
    }
    else
        return FALSE;        
}
Status ClearList(LinkList* L)
{
    Link p, q;
    if (L->head != L->tail)
    {
        p = q = L->head->next;
        L->head->next = NULL;

        while (p != L->tail)
        {
            p = q->next;
            free(q);
            q = p;
        }

        free(q);

        L->tail = L->head;
        L->len = 0;
    }
    return OK;
}

Position GetHead(LinkList* L)
{
    return L->head;
}

Position NextPos(Link p)
{
    return p->next;
}
Position PriorPos(LinkList L, Link p)
{
    Link q;
    q = L.head;

    while (q->next != p)
    {
        q = q->next;
    }
    return q;

}

void FreeNode(Link* p)
{
    free((*p));
    (*p) = NULL;
}

Status ListEmpty(LinkList L)
{
    if (L.len == 0)
        return TRUE;
    else
        return FALSE;
}

ElemType GetCurElem(Link p)
{
    return p->data;
}

Status Append(LinkList* L, Link s)
{
    int i = 1;
    (*L).tail->next = s;  
    while (s->next)       
    {
        i++;
        s = s->next;
    }
    (*L).tail = s;        
    (*L).len += i;        
    return OK;
}
void DestroyPolyn(LinkList* L)
{
    ClearList(L);        
    FreeNode(&(*L).head);  
    (*L).tail = NULL;
    (*L).len = 0;
}
int cmp(term e1, term e2)
{
    if (e1.expn == e2.expn) return 0;
    if (e1.expn < e2.expn) return -1;
    return 1;
}
Status LocateElem(LinkList L, ElemType e, Position* q, int (*compare)(ElemType, ElemType))
{
    Link p, pp;
    p = L.head;
    do
    {
        pp = p;
        p = p->next;
    } while (p && compare(p->data, e) < 0);   //找到第一个大于等于e的位置

    if (!p || compare(p->data, e) > 0)   //到表尾或者找到的位置的值并不相等
    {
        (*q) = pp;   //使q指示第一个大于e的结点的直接前驱
        return FALSE;
    }
    else   //找到相等
    {
        (*q) = p;
        return TRUE;
    }
}
void CreatPolyn(polynomial* P, int m)
{
    Position q, s;
    int i;
    term e;
    InitList(P); 
    e.coef = 0.0;
    e.expn = -1;
    printf("请输入%d个系数，指数：\n", m);
    for (i = 1; i <= m; i++)
    {
        scanf_s("%f %d", &e.coef, &e.expn);
        if (!LocateElem(*P, e, &q, cmp)) 
        {
            if (MakeNode(&s, e))  
                InsFirst(P, q, s);   
        }
    }
}
void PrintPolyn(polynomial P)
{
    Link q;
    q = P.head->next;  
    printf("系数  指数\n");

    while (q)
    {
        printf("%.2f  %d\n", q->data.coef, q->data.expn);
        q = q->next;
    }
}
int PolynLength(polynomial P)
{
    Link q;
    int i;

    q = P.head;
    i = 0;

    while (q != P.tail)
    {
        q = q->next;
        i++;
    }
    return i;
}
void AddPolyn(polynomial* Pa, polynomial* Pb)
{
    Position ha, hb, qa, qb;
    term a, b;
    ha = GetHead(Pa);
    hb = GetHead(Pb);
    qa = NextPos(ha);
    qb = NextPos(hb);
    while (!ListEmpty(*Pa) && !ListEmpty(*Pb) && qa)
    {
        a = GetCurElem(qa);
        b = GetCurElem(qb);
        switch (cmp(a, b))
        {
        case -1: 
            ha = qa;
            qa = NextPos(qa); 
            break;
        case 0:  
            qa->data.coef += qb->data.coef;
            if (qa->data.coef)
            {
                ha = qa;
            }
            else  
            {
                DelFirst(Pa, ha, &qa);
                FreeNode(&qa);
            }
            DelFirst(Pb, hb, &qb);
            FreeNode(&qb);
            qa = NextPos(ha);
            qb = NextPos(hb);
            break;
        case 1:  
            DelFirst(Pb, hb, &qb);
            InsFirst(Pa, ha, qb);
            qb = NextPos(hb);
            ha = NextPos(ha);
        }
    }
    if (!ListEmpty(*Pb))
    {
        Pb->tail = hb;  
        Append(Pa, qb);
    }
    DestroyPolyn(Pb);
}
void Calculate(polynomial pa, float x)
{
    Position p;
    float t=0;
    p = pa.head->next;
    while (p)
    {
        t += p->data.coef * pow(x, p->data.expn);
        p = p->next;
    }
    printf("%.2f", t);
}
void Oppsite(polynomial* Pa)
{
    Position p;
    p = Pa->head->next;
    while (p)
    {
        p->data.coef *= -1;
        p = p->next;
    }
}
void SubtractPolyn_N(polynomial* Pa, polynomial* Pb)
{
    Oppsite(Pb);
    AddPolyn(Pa, Pb);

}
void main()
{
    polynomial p, q;
    int m;
    float x;
    printf("请输入第一个多项式的项数：");
    scanf_s("%d", &m);
    CreatPolyn(&p, m);
    PrintPolyn(p);
    printf("请输入第二个多项式的项数:");
    scanf_s("%d", &m);
    CreatPolyn(&q, m);
    PrintPolyn(q);
    //printf("两个一元多项式和表示为：\n");
    //AddPolyn(&p, &q);
    printf("两个一元多项式差表示为：\n");
    SubtractPolyn_N(&p, &q);
    PrintPolyn(p);
    printf("\n");
    printf("请输入x的值：");
    scanf_s("%f", &x);
    printf("计算结果为：\n");
    Calculate(p, x);
   
    DestroyPolyn(&p);
}

 运行结果：

 

scanf_s 是 Microsoft 特有的一个函数，它是 scanf 函数的一个安全版本，旨在防止缓冲区溢出等安全问题。在 C 语言的标准库中，scanf 函数用于从标准输入（通常是键盘）读取数据，并根据指定的格式字符串将输入的数据存储在变量中。然而，由于 scanf 不会检查目标缓冲区的大小，如果输入的数据超出了目标缓冲区的大小，就可能导致缓冲区溢出，这是一个常见的安全漏洞。为了解决这个问题，Microsoft 在其编译器（如 MSVC）中引入了 scanf_s 和其他一系列以 _s 结尾的安全函数。这些函数要求程序员显式地指定目标缓冲区的大小，从而在一定程度上减少了缓冲区溢出的风险。

数组表示：

#include <stdio.h>
#include <stdlib.h>
#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0
#define MAX_SIZE 100
typedef int Status;
typedef struct {
    float coef;   
    int expn;   
} term;
typedef struct {
    term* elems;  
    int length;   
    int listsize;
} Polynomial;

Status InitPoly(Polynomial* P) {
    P->elems = (term*)malloc(MAX_SIZE * sizeof(term));
    if (!P->elems) return ERROR;
    P->length = 0;
    P->listsize = MAX_SIZE;
    return OK;
}
void DestroyPoly(Polynomial* P) {
    free(P->elems);
    P->elems = NULL;
    P->length = 0;
}
Status InsertElem(Polynomial* P, int pos, term e) {
    if (pos < 0 || pos > P->length || P->length >= MAX_SIZE) return ERROR;
    for (int i = P->length; i > pos; i--) {
        P->elems[i] = P->elems[i - 1];
    }
    P->elems[pos] = e;
    P->length++;
    return OK;
}
Status DeleteElem(Polynomial* P, int pos) {
    if (pos < 0 || pos >= P->length) return ERROR;
    for (int i = pos; i < P->length - 1; i++) {
        P->elems[i] = P->elems[i + 1];
    }
    P->length--;
    return OK;
}
int Cmp(term a, term b) {
    if (a.expn < b.expn) return -1;
    if (a.expn > b.expn) return 1;
    return 0;
}
void PrintPoly(Polynomial P) {
    for (int i = 0; i < P.length; i++) {
        printf("%.2f %d\n", P.elems[i].coef, P.elems[i].expn);
    }
}
void AddPoly(Polynomial* Pa, Polynomial* Pb, Polynomial* Res) {
    int i = 0, j = 0, k = 0;
    float s;
    while (i < Pa->length && j < Pb->length)
    {
        if (Cmp(Pa->elems[i], Pb->elems[j]) < 0) {
            Res->elems[k++] = Pa->elems[i++];
        }
        else if(Cmp(Pa->elems[i], Pb->elems[j]) == 0)
        {
            s= Pa->elems[i].coef + Pb->elems[j].coef;
            if (s != 0)
            {
                Res->elems[k].coef = s;
                Res->elems[k].expn = Pa->elems[i].expn;
                k++;              
            }  
            i++;
            j++;                           
        }
        else
        {
            Res->elems[k++] = Pb->elems[j++];
        }
    }
    while (i < Pa->length) {
        Res->elems[k++] = Pa->elems[i++];
    }
    while (j < Pb->length) {
        Res->elems[k++] = Pb->elems[j++];
    }
    Res->length = k;
}
void Sort_s(Polynomial* L)
{
    int i, j, k;
    term t;
    for (i = 0; i < L->length - 1; i++)
    {
        k = i;
        for (j = i + 1; j < L->length; j++)
        {
            if (L->elems[k].expn > L->elems[j].expn)
                k = j;
        }
        if (k != i)
        {
            t.expn = L->elems[i].expn;
            t.coef = L->elems[i].coef;
            L->elems[i].expn = L->elems[k].expn;
            L->elems[i].coef = L->elems[k].coef;
            L->elems[k].expn = t.expn;
            L->elems[k].coef = t.coef;
        }
    }
}
void CreatePolyn_s(Polynomial* p, int m)
{
    int i;
    InitPoly(p);
    p->elems[p->length].coef = 0.0;
    p->elems[p->length].expn = 0;
    printf("请输入%d个系数，指数：\n", m);
    for(i=0;i<m;i++)
        scanf_s("%f %d", &p->elems[i].coef, &p->elems[i].expn);
    p->length = m;
    Sort_s(p);
}
void Oppsite_s(Polynomial* Pa)
{
    for (int i = 0; i < Pa->length; i++)
        Pa->elems[i].coef *= -1;
}
SubtractPolyn_s(Polynomial* p, Polynomial* q, Polynomial* r)
{
    Oppsite_s(q);
    AddPoly(p, q, r);
}
int main() {
    Polynomial p, q, result,R;
    int m, n;
    printf("请输入第一个多项式的项数: ");
    scanf_s("%d", &m);
    CreatePolyn_s(&p,m);
    PrintPoly(p);
    printf("请输入第二个多项式的项数: ");
    scanf_s("%d", &n);
    CreatePolyn_s(&q,n);
    PrintPoly(q);
    InitPoly(&result);
    AddPoly(&p, &q, &result);
    printf("两一元多项式和表示为:\n");
    PrintPoly(result);
    printf("两一元多项式差表示为:\n");
    InitPoly(&R);
    SubtractPolyn_s(&p, &q, &R);
    PrintPoly(R);
    DestroyPoly(&p);
    DestroyPoly(&q);
    DestroyPoly(&result); 
    DestroyPoly(&R);
    return 0;
}