# 一元多项式

``````#include
#include

typedef struct Node{
int a;
int b;
struct Node *next;
}node;

#define SIZE sizeof(node)

node *initList();
node *listSub(node *A, node *B);
node *listTime(node *A, node *B);
int listIs(node *A,int x);
node *listDer(node *A);
void func(node *a, node *b);

int main(){
int n;
// 相减
scanf("%d\n", &n);
node *h1 = initList();
creatList(h1,n);

scanf("%d\n", &n);
node *h2 = initList();
creatList(h2,n);

printf("sub:\n");
printList(h1);
printList(h2);
node *h3 = listSub(h1,h2);
printList(h3);
// 相乘
scanf("%d\n", &n);
node *h4 = initList();
creatList(h4,n);

scanf("%d\n", &n);
node *h5 = initList();
creatList(h5,n);

node *h6 = listTime(h4,h5);
printf("time:\n");
printList(h4);
printList(h5);
printList(h6);
// 求导
scanf("%d\n", &n);
node *h7 = initList();
creatList(h7,n);

node *h8 = listDer(h7);
printf("der:\n");
printList(h7);
printList(h8);

return 0;
}

node *initList(){
node *p = (node*)malloc(SIZE);
p->next = NULL;
return p;
}
while (n--) {
node *new = (node*)malloc(SIZE);
scanf("(%d,%d)", &new->a, &new->b);
pre->next = new;
pre = new;
}
pre->next = NULL;
}
while (cur != NULL) {
int a = cur->a;
int b = cur->b;
if(a > 0)
printf("+");
}
printf("%d", a);
if(b != 0){
printf("X");
if (b != 1)
printf("^%d", b);
}
cur = cur->next;
}
printf("0");
}
printf("\n");
}
node *list = initList();
node *pre = list;
node *Acur = A->next;
node *Bcur = B->next;
int a1,a2,b1,b2;
while (Acur && Bcur) {
a1 = Acur->a;
b1 = Acur->b;
a2 = Bcur->a;
b2 = Bcur->b;
node *new = (node*)malloc(SIZE);
if(b1 == b2){
if (a1 != -a2){
new->a = a1 + a2;
new->b = b1;
pre->next = new;
pre = new;
Acur = Acur->next;
Bcur = Bcur->next;
}else{
Acur = Acur->next;
Bcur = Bcur->next;
}
}else if (b1 < b2) {
new->a = a1;
new->b = b1;
pre->next = new;
pre = new;
Acur = Acur->next;
}else if (b1 > b2) {
new->a = a2;
new->b = b2;
pre->next = new;
pre = new;
Bcur = Bcur->next;
}
}
if(!Acur){
pre->next = Bcur;
}else{
pre->next = Acur;
}
return list;
}
node *listSub(node *A, node *B){
node *list = initList();
node *pre = list;
node *Acur = A->next;
node *Bcur = B->next;
int a1,a2,b1,b2;
while(Bcur){
Bcur->a *= -1;
Bcur = Bcur->next;
}
Bcur = B->next;
while (Acur && Bcur) {
a1 = Acur->a;
b1 = Acur->b;
a2 = Bcur->a;
b2 = Bcur->b;
node *new = (node*)malloc(SIZE);
if(b1 == b2){
if (a1 != -a2){
new->a = a1 + a2;
new->b = b1;
pre->next = new;
pre = new;
Acur = Acur->next;
Bcur = Bcur->next;
}else{
Acur = Acur->next;
Bcur = Bcur->next;
}
}else if (b1 < b2) {
new->a = a1;
new->b = b1;
pre->next = new;
pre = new;
Acur = Acur->next;
}else if (b1 > b2) {
new->a = a2;
new->b = b2;
pre->next = new;
pre = new;
Bcur = Bcur->next;
}
}
if(!Acur){
pre->next = Bcur;
}else{
pre->next = Acur;
}
return list;
}
node *listTime(node *A, node *B){
node *list = initList();
node *Acur = A->next;
node *Bcur = B->next;
node *pre = list;
while (Acur) {
while (Bcur) {
int a1 = Acur->a;
int a2 = Bcur->a;
int b1 = Acur->b;
int b2 = Bcur->b;
node *new = (node*)malloc(SIZE);
new->a = a1 * a2;
new->b = b1 + b2;
pre->next = new;
pre = new;
Bcur = Bcur->next;
}
Bcur = B->next;
Acur = Acur->next;
}
pre->next = NULL;
//合并同类项
funa(list);
//排序
funb(list);
return list;
}

while (cur) {
int b1 = cur->b;
node *Npre = cur;
node *Ncur = cur->next;
while (Ncur) {
int b2 = Ncur->b;
if (b1 == b2) {
// printf("a1=%d a2=%d\n",b1,b2);
Npre->next = Ncur->next;
cur->a = cur->a + Ncur->a;
Ncur = Ncur->next;
}
Npre = Npre->next;
Ncur = Ncur->next;
}
cur = cur->next;
}
}
node *cur = pre->next;
while (cur) {
node *Npre = cur;
node *Ncur = Npre->next;
while (Ncur) {
int b1 = cur->b;
int b2 = Ncur->b;
if(b1 > b2){
func(cur, Ncur);
}
Ncur = Ncur->next;
}
cur = cur->next;
}
}
//   node *pre = cur;
//   while (cur) {
//     node *Npre = cur;
//     node *Ncur = Npre->next;
//     while (Ncur) {
//       int b1 = cur->b;
//       int b2 = Ncur->b;
//       if (b1 > b2){
//         node *new = Npre->next;
//         pre->next = Ncur;
//         Npre->next = cur;
//         Ncur->next = cur->next;
//         cur->next = new;
//
//         node *p = Ncur;
//         Ncur = cur;
//         cur = p;
//       }
//       Ncur = Ncur->next;
//     }
//     cur = cur->next;
//   }
// }
void func(node *a, node *b){
int na = a->a;
int nb = a->b;

a->a = b->a;
a->b = b->b;

b->a = na;
b->b = nb;
}
int listIs(node *A, int x){
int sum = 0;
node *cur = A->next;
while (cur != NULL) {
int a = cur->a;
int b = cur->b;
sum += a * pow(x,b);
cur = cur->next;
}
return sum;
}
node *cur = pre->next;
node *list = initList();
node *Npre = list;
while (cur) {
if (cur->b != 0){
node *new = (node*)malloc(SIZE);
int a = cur->a;
int b = cur->b;
new->a = a * b;
new->b = b-1;
Npre->next = new;
Npre = new;
}
cur = cur->next;
}
Npre->next = NULL;
return list;
}

``````