PTA-简单一元多项式的基本运算（不含除法）

题目类型

输入多项式，进行一系列运算后输出。

输入样式

第一行输入项数，第二行以（系数，指数）的方式输入数据。

4
(6,0)(2,1)(-8,70)(4,150)

输出样式

6+2X-8X^70+4^150

通用代码

注意看注释

/* 多项式的运算器 */
/* 使用手册在主函数中以注释方式给出，目前求导有问题，只能对一半 */
/* 本程序只针对pta平台的作业，如若需要其他用途，请自行修改 */
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#define OK 1

typedef struct Ploy{
    /* data */
    int num;    //项数
    int index;  //指数
    struct Ploy *next;
}PloyNode, *PloyLL;

typedef struct {
    PloyLL ployLL;
    PloyLL end;  //也没用
    int len;   //没怎么用到，忽略它
    
}LLHead, *ListHead;

void Init(ListHead ployhead);  //初始化空表，带头结点
int ListInsert(ListHead ployhead, PloyNode *data);   //插入一项
int Print(ListHead ployhead);   //输出结果
int Input(ListHead ployhead);   //输入数据
int ReInput(ListHead ployhead); //反向输入， num变负
int Devt(ListHead ployhead);   //求导
int Sum(ListHead ployhead);  //求值
ListHead Mult(ListHead ployhead1, ListHead ployhead2); //乘法

int main(void) {
    /* 建立与输出 */
    /* ListHead elem = (ListHead)malloc(sizeof(LLHead));  声明指针变量并申请内存空间
    Init(elem);         初始化链表
    Input(elem);        输入信息，参数为声明的指针变量
    Print(elem);        输出信息，参数为声明的指针变量 */

    /* 加法or减法 */
    /* ListHead elem = (ListHead)malloc(sizeof(LLHead));  声明指针变量并申请内存空间
    Init(elem);         初始化链表
    Input(elem);        输入信息，参数为声明的指针变量
    选择其一：
    减法调用：ReInput(elem);
    加法再次调用：Input(elem);   
    Print(elem);        输出信息，参数为声明的指针变量 */

    /* 乘法 */
    /* 
    ListHead elem1 = (ListHead)malloc(sizeof(LLHead));  声明指针变量并申请内存空间
    ListHead elem2 = (ListHead)malloc(sizeof(LLHead));  声明指针变量并申请内存空间
    Init(elem1);         初始化链表1
    Init(elem2);         初始化链表2
    Input(elem1);        输入信息，参数为声明的指针变量
    Input(elem2);        输入信息，参数为声明的指针变量
    Print(Muit(elem1, elem2));        输出信息，参数为Muit函数的返回值
    */

   /* 求值 */
   /* ListHead elem = (ListHead)malloc(sizeof(LLHead));  声明指针变量并申请内存空间
    Init(elem);         初始化链表
    Input(elem);        输入信息，参数为声明的指针变量
    Sum(elem);          求值
     */

    /* 求导 */
    /* ListHead elem = (ListHead)malloc(sizeof(LLHead));  声明指针变量并申请内存空间
    Init(elem);         初始化链表
    Input(elem);        输入信息，参数为声明的指针变量
    Devt(elem);         求导，参数为声明的指针变量
    Print(elem);        输出信息，参数为声明的指针变量 */
    return 0;
}

void Init(ListHead ployhead) {
    ployhead->len = 0;
    PloyNode *head_node = (PloyNode *)malloc(sizeof(PloyNode));
    head_node->next = NULL;
    ployhead->ployLL = head_node;
    ployhead->end = head_node;
}

int ListInsert(ListHead ployhead, PloyLL data) {
    PloyLL head = ployhead->ployLL->next;
    PloyLL pre = ployhead->ployLL;
    PloyLL f;
    /* 指数重复检查 */
    while (head != NULL)
    {
        
        if(head->index == data->index) {
            head->num += data->num;     //合并
            if(head->num == 0) {  //合并后num为零检查
                f = head;
                pre->next = head->next;
                head = head->next;
                free(f);
                ployhead->len--;
            }
            return OK;
        }
        head = head->next;
        pre = pre->next;
    }
    head = ployhead->ployLL->next; // 重置
    pre = ployhead->ployLL;
    while(head != NULL) {   //寻找位置，按顺序插入
        if(data->index > head->index) {
            head = head->next;
            pre = pre->next;
        }
        else {
            break;
        }
    }
    data->next = head;
    pre->next = data;
    ployhead->len++;

    return OK;
}

/* 输出结果 */
int Print(ListHead ployhead) {
    PloyLL datahead = ployhead->ployLL->next;
    if(datahead == NULL) {
        printf("0");
        return 0;
    }
    while(datahead->next != NULL) {
        
        /* printf("%d", datahead->num > 0 ? datahead->num : -datahead->num); */
        printf("%d", datahead->num);
        if(datahead->index != 0) {
            printf("%c", 'X');
        } 
        if(datahead->index != 0 && datahead->index != 1) {
            printf("%c%d", '^', datahead->index);
        }
        if(datahead->next->num > 0) {
            printf("%c", '+');
        }
        /* else {
            printf("%c", '-');
        } */
        datahead = datahead->next;
        
    }
    printf("%d", datahead->num);
    if(datahead->index != 0) {
        printf("%c", 'X');
    } 
    if(datahead->index != 0 && datahead->index != 1) {
        printf("%c%d", '^', datahead->index);
    }
}

int Input(ListHead ployhead) {
    int n, num, index;
    char laji[3];  //接受无用字符
    
    scanf("%d" ,&n);
    getchar();   
    getchar();    //PTA的锅
    for(int i = 0; i < n; i++) {
        PloyNode *data = (PloyNode *)malloc(sizeof(PloyNode));
        scanf("%c%d%c%d%c", &laji[0], &num, &laji[1], &index, &laji[2]);
        
        if(num == 0) {
            continue;
        }
        data->num = num;
        data->index = index;
        ListInsert(ployhead, data);
    }
}

int ReInput(ListHead ployhead) {
    int n, num, index;
    char laji[3];
    
    scanf("%d" ,&n);
    getchar();
    getchar();    //PTA的锅
    for(int i = 0; i < n; i++) {
        PloyNode *data = (PloyNode *)malloc(sizeof(PloyNode));
        scanf("%c%d%c%d%c", &laji[0], &num, &laji[1], &index, &laji[2]);
        if(num == 0) {
            continue;
        }
        data->num = -num;  //减法使用
        data->index = index;
        ListInsert(ployhead, data);
    }
}

int Devt(ListHead ployhead) {
    PloyLL elem = ployhead->ployLL->next;
    PloyLL pre = ployhead->ployLL;
    PloyLL f;
    while(elem != NULL) {
        if(elem->index == 0) {
            f = elem;
            pre->next = elem->next;
            elem = elem->next;
            free(f);
            continue;
        }
        else {
            
            elem->num *= elem->index;
            elem->index--;
        }
        elem = elem->next;
        pre = pre->next;
    }
    return OK;
}

int Sum(ListHead ployhead) {
    int x; 
    double sum = 0;
    scanf("%d", &x);
    PloyLL head = ployhead->ployLL->next;
    while (head != NULL)
    {
        sum += ((double)head->num) * pow((double)x, (double)head->index);
        head = head->next;
    }
    printf("%d",(int)sum);
    return OK;
}


ListHead Mult(ListHead ployhead1, ListHead ployhead2) {
    ListHead rtn = (ListHead)malloc(sizeof(LLHead));
    Init(rtn);
    
    PloyLL head1 = ployhead1->ployLL->next;
    PloyLL head2 = ployhead2->ployLL->next;
    while(head1 != NULL) {
        head2 = ployhead2->ployLL->next;
        while(head2 != NULL) {
            PloyLL data = (PloyLL)malloc(sizeof(PloyNode));
            data->index = head1->index + head2->index;
            data->num = head1->num * head2->num;
            ListInsert(rtn, data);
            head2 = head2->next;
        }
        head1 = head1->next;
    }
    return rtn;
}

这段代码对于求导部分始终有一个测试点无法通过，如果读者能发现问题，欢迎在评论区告诉我qwq