数据结构多项式--加法、乘法、减法（C语言）友好界面

最新推荐文章于 2024-05-18 21:50:26 发布
最新推荐文章于 2024-05-18 21:50:26 发布
阅读量3.3k 收藏 49
点赞数 13
文章标签： 数据结构 c语言 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_56108311/article/details/122175498
版权

问题重述

一元稀疏多项式简单计算器的基本功能是：

(1)输入并建立多项式；

(2)输出多项式，输出形式为整数序列：n,c1,e1,c2,e2,…,cn,en,

其中n是多项式的项数，ci,ei分别是第i项的系数和指数，序列按指数降序排列；

(3)多项式a和b相加，建立多项式a+b；

(4)多项式a和b相减，建立多项式a-b；

(5)计算多项式在x处的值；即给定x值，计算多项式值。

拓展:多项式乘法；多项式系数的合并和排序（无论是指数大的在前面还是指数小的在前面，都可以，或者指数相同的项输入了多次，都可以进行处理，先进行多项式系数的合并和排序，形成一个指数由小到大排列多项式）

分析过程

一：输入多项式的系数和指数，初始化多项式。（其中多项式的结构如下:

typedef struct Node {

    float coef;   //系数

    int exp;      //指数

    struct Node* next;

}Node, * Ploy;

typedef Ploy* ptrPloy;)）//采用二重指针便于直接修改链表的值。

二:对多项式的按指数进行排序，然后将指数一样的节点进行合并。因此就实现了对序列按指数由小到大依次排序。

三:对多项式的x进行赋值求和并输出结果，就可以直接从头节点开始，遍历一遍多项式链，每到一个节点，就令coef=x(所赋予的值),然后计算coef^exp,将所有节点的值累加起来就是最终所要求的值。

四：多项式的加法与减法原理一样：现只分析加法。由于创建好的两个相加的多项式已经按指数从低到高已经排好序，对两个多项式进行加法的过程就好比对两个多项式的指数进行归并排序，在排序过程中对系数对应的系数进行加法运算，而且这里所说的归并排序只不过所用的归并不用递归，只用一趟就可以得到最终的结果，但系数相加后可能为0，就需要删除这个节点。

五：多项式的乘法（拓展）：运用双层循环，将多项式1中所有的节点都与多项式2中所有的节点进行乘法运算（系数*系数，指数*指数），然后用这些节点重新构建一个多项式，最后对多项式进行排序和合并操作就可以得到最终结果，刚开始再创建多项式时会浪费n*m(n，m分别为多项式1和2的节点数)，但是经过排序和合并操作就会将多余节点的空间释放掉）。

程序评价

1.多项式加法和减法的核心函数

  1. void Add_Ploy(ptrPloy pa, ptrPloy pb, ptrPloy pc);  //进行多项式的加法
  2. void Sub_Ploy(ptrPloy pa, ptrPloy pb, ptrPloy pc);  //进行多项式的减法

设pa长度为m，pb的长度为n

最好时间复杂度为O（Max(m,n)）,最坏时间复杂度为O（m+n）;

本算法不需要额外空间，首先令pc=pa，然后将pb中各个节点插入pc中合适的位置或者与pc中的节点合并。

2.在对多项式序列进行排序时，本函数采用了冒泡排序，由于数据结构为单链表，无法采用高级排序算法，希尔排序，堆排序等（这些算法用到了数组的随机存取的特点），当然这里的排序也可以使用简单选择排序或者直接插入排序，但在时间复杂度上并没有数量级的变化，但是采用简单选择排序可以减少节点交换次数。

3.设计了清晰的交互式界面，便于操作；

4.添加了外部导入文件的传输方式，并将结果写入到txt文件中，便于对后续数据的处理。

 

 

5.依据加法和减法的思想，进行拓展，增加了多项式相乘的算法。该算法的时间复杂度为O（m*n），空间复杂度为O（m*n）,如果多项式的某些节点的指数值相同，就会进行合并操作并释放掉多余的空间。

6.多项式打印函数考虑情况复杂，还用多层判断语句实现对多项式的精准打印。还有在合并多项式时，也进行了精准判断，如当多项式为y=0。

源代码

 ​​​​​

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<stdlib.h>
#include<math.h>

//采用带链表进行多项式的加法、减法和乘法

//延伸：倘若输入的指数是无序的，而且可能是重复的，则牵扯到排序与合并。
//现尝试编写void Sort_and_Merge_Ploy(ptrPloy Head)函数

//多项式乘法void Mult_Ploy()

//多项式求和函数：对多项式赋值后进行求和void Sum_Ploy()

//多项式分解函数？

typedef struct Node {
 float coef;   //系数
 int exp;      //指数
 struct Node* next;
}Node, * Ploy;
typedef Ploy* ptrPloy;

void Init_Ploy(ptrPloy Head);                       //初始化操作

void Add_Ploy(ptrPloy pa, ptrPloy pb, ptrPloy pc);  //进行多项式的加法
void Sub_Ploy(ptrPloy pa, ptrPloy pb, ptrPloy pc);  //进行多项式的减法
void Mult_Ploy(ptrPloy pa, ptrPloy pb, ptrPloy pc); //进行多项式的乘法
void Sum_Ploy(ptrPloy Head, float x,FILE* fp);      //对多项式x进行赋值，然后求和

void Import_Ploy(ptrPloy Head);                     //输入多项式

void Sort_and_Merge_Ploy(ptrPloy Head);            //对多项式内部进行排序和合并,其中排序采用快速||冒泡排序

//对单链表冒泡排序
void Bubble_Ploy(Ploy head);     

//合并同类项
void Merge(Ploy head);

void Print_Ploy(ptrPloy Head,FILE* fp);                         //打印多项式
void Create_Ploy(ptrPloy Head,FILE* fp);                        //对初始化，输入，打印操作进行封装，将主函数模块化，向面向对象方法靠近
void Create_Ploy_txt(ptrPloy Head, FILE* fp);                   //以文本文件形式传输数据
void Final_Add_Ans(ptrPloy pa, ptrPloy pb, ptrPloy pc,FILE* fp);    //输出最终相加后的结果
void Final_Sub_Ans(ptrPloy pa, ptrPloy pb, ptrPloy pc,FILE* fp);    //输出最终相减后的结果
void Final_Mult_Ans(ptrPloy pa, ptrPloy pb, ptrPloy pc,FILE* fp);   //输出最终相乘后的结果
void Command_Ploy(void);                                   //命令提醒

int main()
{
 ptrPloy ploy,ploy1, ploy2,ploy3;
 FILE* fp;
 int flag = 1;
 int tag;
 int way;

 if ((fp = fopen("result.txt", "wb+")) == NULL) {
  perror("the file fail to write");
  system("pause");
  exit(1);
 }

 while (flag) {
  int choice;
  float x=0;
  Command_Ploy();
  scanf_s("%d", &choice);
  switch (choice) {
  case 1:
   printf("请选择数据传输方式：1.外部导入 2.手动输入\nchoice:");
   scanf_s("%d", &way);
   while (way < 1 || way>2) {
    printf("请选择正确的传输方式:1.外部导入 2.手动输入\nchoice:");
    scanf_s("%d", &way);
   }
   way==1?Create_Ploy_txt(&ploy,fp):Create_Ploy(&ploy,fp);
   tag = 0;
   break;
  case 2:
   printf("请输入x=");
   scanf_s("%f", &x);
   tag == 0 ? Sum_Ploy(&ploy, x,fp) : Sum_Ploy(&ploy3, x,fp);
   break;
  case 3:
   fprintf(fp, "多项式加法:\n");
   Create_Ploy(&ploy1,fp);
   Create_Ploy(&ploy2,fp);
   Final_Add_Ans(&ploy1, &ploy2, &ploy3,fp);
   tag = 1;
   break;
  case 4:
   fprintf(fp, "多项式减法:\n");
   Create_Ploy(&ploy1,fp);
   Create_Ploy(&ploy2,fp);
   Final_Sub_Ans(&ploy1, &ploy2, &ploy3,fp);
   tag = 1;
   break;
  case 5:
   fprintf(fp, "多项式乘法:\n");
   Create_Ploy(&ploy1,fp);
   Create_Ploy(&ploy2,fp);
   Init_Ploy(&ploy);
   Final_Mult_Ans(&ploy1, &ploy2, &ploy3,fp);
   tag = 1;
   break;
  case 6:
   flag = 0;
   break;
  default:
   break;
  }
 }
 fclose(fp);
 return 0;
}


void Init_Ploy(ptrPloy Head)
{
 Ploy temp;
 if (*Head == NULL);
 {
  temp = (Ploy)malloc(sizeof(Node));
  if (*Head == NULL)
  {
   printf("初始化失败！\n");
   return;
  }
  *Head = temp;
  (*Head)->next = NULL;
 }
 printf("初始化成功!\n");
 return;

}

void Add_Ploy(ptrPloy pa, ptrPloy pb, ptrPloy pc)
{
 *pc = *pa;
 Ploy at = (*pa)->next;
 Ploy bt = (*pb)->next;
 Ploy ct = (*pc);
 Ploy tag;
 float temp;
    while (at && bt) {
  if (at->exp < bt->exp) {
   ct = at;
   at = at->next;
  }
  else if (at->exp == bt->exp) {
   temp = at->coef + bt->coef;
   if (temp != 0) {
    at->coef = temp;
    ct = at;
   }
   else {
    ct->next = at->next;
    free(at);
   }
   at = ct->next;
   bt = bt->next;
  }
  else {
   tag = bt->next;
   bt->next = at;
   ct->next = bt;
   ct = ct->next;  // ct往后移
   bt = tag;
  }
 }
 if (bt != NULL) {
  Ploy temp = (Ploy)malloc(sizeof(Node));
  if (temp) {
   temp = bt;
   ct->next = temp;
  }
  //ct->next = bt;
 }
 //free(pb);
}

void Sub_Ploy(ptrPloy pa, ptrPloy pb, ptrPloy pc)
{
 *pc = *pa;
 Ploy at = (*pa)->next;
 Ploy bt = (*pb)->next;
 Ploy ct = (*pc);
 Ploy tag;
 float temp;
 while (at && bt) {
  if (at->exp < bt->exp) {
   ct = at;
   at = at->next;
  }
  else if (at->exp == bt->exp) {
   temp = at->coef - bt->coef;
   if (temp != 0) {
    at->coef = temp;
    ct = at;
   }
   else {
    ct->next = at->next;
    free(at);
   }
   at = ct->next;
   bt = bt->next;
   
  }
  else {
   tag = bt->next;
   bt->next = at;
   ct->next = bt;
   bt->coef = -bt->coef;
   ct = ct->next;  // ct往后移
   bt = tag;
  }
 }
 if (bt != NULL) {
  Ploy temp = (Ploy)malloc(sizeof(Node));
  if (temp) {
   bt->coef = -bt->coef;
   temp = bt;
   ct->next = temp;
  }
  //ct->next = bt;
 }
 //free(pb);
}

void Mult_Ploy(ptrPloy pa, ptrPloy pb, ptrPloy pc)
{
 Ploy at = (*pa)->next;
 Ploy bt = (*pb)->next;

 //初始化pc
 Ploy p;
 if (*pc == NULL);
 {
  p = (Ploy)malloc(sizeof(Node));
  if (*pc == NULL)
  {
   printf("初始化失败！\n");
   return;
  }
  *pc = p;
  (*pc)->next = NULL;
 }

 Ploy ct = *pc;
 for (at; at!=NULL; at = at->next) {
  for (bt=(*pb)->next; bt!=NULL; bt = bt->next) {
   Ploy temp = (Ploy)malloc(sizeof(Node));
   temp->coef = at->coef * bt->coef;
   temp->exp = at->exp + bt->exp;
     ct->next = temp;
   ct = ct->next;
  }
 }
 ct->next = NULL;
 Sort_and_Merge_Ploy(pc);
}

void Sum_Ploy(ptrPloy Head, float x,FILE* fp)
{
 float sum = 0;
 Ploy p= (*Head)->next;
 while (p) {
  sum+= p->coef * pow(x, p->exp);
  p = p->next;
 }
 printf("当x=%.2f时,多项式的总和为%.2f\n", x, sum);
 fprintf(fp, "当x=%.2f时,多项式的总和为%.2f\n", x, sum);
}

void Import_Ploy(ptrPloy Head)
{
 //printf("请依次输入多项式的系数和对应的指数(当输出回车时,代表输入结束)eg：1 2 3 4 回车(代表x^2+3x^4)\n");
 int exp;
 float coef;
 char ch = 0;//用来停止输入
 Ploy q = *Head;
 Ploy p = (*Head)->next;
 while (ch != '\n') {
  scanf_s("%f %d", &coef, &exp);
  p = (Ploy)malloc(sizeof(Node));
  if (p) {
   p->coef = coef;
   p->exp = exp;
   p->next = q->next;
   q->next = p;
  }
  q = p;
  p = p->next;
     ch = getchar();
 }
}

void Sort_and_Merge_Ploy(ptrPloy Head)
{
 Ploy head = (*Head)->next;
 Bubble_Ploy(head);
 //再Merge
 Merge(head);
}

void Bubble_Ploy(Ploy head)
{
 Ploy p, q;
 int exp;
 float coef;
 if (head == NULL || head->next == NULL) {
  return;
 }

 for (p = head; p != NULL; p = p->next) {
  for (q = p->next; q != NULL; q = q->next) {
   if (p->exp > q->exp) {
    exp = p->exp;
    coef = p->coef;
    p->exp = q->exp;
    p->coef = q->coef;
    q->exp = exp;
    q->coef = coef;
   }//if
  }//for
 }//for
}

void Merge(Ploy head)
{
 Ploy q = (head);
 Ploy p = q->next;
 while (p) {
  while (p != NULL&&(p->exp == q->exp)) {
   q->coef += p->coef;
   p = p->next;
  }
  if (q->coef == 0) {
   if (p == NULL) {
    q->coef = 0;
    q->exp = 0;
   }
   else {
    q->coef = p->coef;
    q->exp = p->exp;
    if (p->next == NULL) p = NULL;
    else p = p->next;
   }
   q->next = p;
  }
  else {
   if (p == NULL) {
    q->next = p;
   }
   else {
    q->next = p;
    q = q->next;
    p = p->next;
   }//else
  }//else
 }//while
}


void Print_Ploy(ptrPloy Head,FILE* fp)
{
 int flag = 0;
 Ploy p = (*Head)->next;
 printf("y=");
 fprintf(fp, "y=");
 while (p) {
  if (p->coef != 0) {
   if ((p)->exp == 0) {
    printf("%.0f", (p)->coef);
    fprintf(fp, "%.0f", (p)->coef);
    flag = 1;
   }

   else if ((p)->coef > 0) {
    if ((p)->coef == 1) {
     if ((p)->exp == 1) {
      flag == 0 ? printf("x") : printf("+x");
      flag==0?fprintf(fp, "x") :fprintf(fp, "+x");
      flag = 1;
     }
     else {
      flag == 0 ? printf("x^%d", (p)->exp) : printf("+x^%d", (p)->exp);
      flag == 0 ? fprintf(fp,"x^%d", (p)->exp) : fprintf(fp,"+x^%d", (p)->exp);
      flag = 1;
     }
    }
    else {
     if (p->exp == 1)
     {
      printf("%.0fx", p->coef);
      fprintf(fp, "%.0fx", p->coef);
     }
     else {
      flag == 0 ? printf("%.0fx^%d", (p)->coef, (p)->exp) : printf("+%.0fx^%d", (p)->coef, (p)->exp);
      flag == 0 ? fprintf(fp,"%.0fx^%d", (p)->coef, (p)->exp) : fprintf(fp,"+%.0fx^%d", (p)->coef, (p)->exp);
     }
     flag = 1;
    }
   }

   else {
    if ((p)->coef == -1) {
     if ((p)->exp == 1) {
      printf("-x");
      fprintf(fp, "-x");
      flag = 1;
     }
     else {
      printf("-x^%d", (p)->exp);
      fprintf(fp,"-x^%d", (p)->exp);
      flag = 1;
     }
    }
    else {
     if (p->exp == 1) {
      printf("%.0fx", p->coef);
      fprintf(fp,"%.0fx", p->coef);
     }
     else {
      printf("%.0fx^%d", (p)->coef, (p)->exp);
      fprintf(fp, "%.0fx^%d", (p)->coef, (p)->exp);
     }
     flag = 1;
    }//else
   }//else
  }
  p = p->next;
 }
 //如果没有输出其他格式，说明多项式为0
 if (flag == 0) {
  printf("0");
  fprintf(fp, "0");
 }
 printf("\n");
 fprintf(fp, "\n");
 return;
}

void Create_Ploy(ptrPloy Head,FILE* fp)
{
 printf("ploy：");
 Init_Ploy(Head);
 printf("请依次输入ploy多项式的系数和对应的指数(可以不用按递增顺序输入，当输出回车时, 代表输入结束)\neg：1 2 3 4 回车(代表x ^ 2 + 3x ^ 4)\ninput:");
 Import_Ploy(Head);
 Sort_and_Merge_Ploy(Head);
 printf("你输入的ploy多项式为：\noutput:");
 Print_Ploy(Head,fp);
}

void Create_Ploy_txt(ptrPloy Head, FILE* fp)
{
 printf("ploy：");
 Init_Ploy(Head);
 FILE* fp1;

 int exp;
 float coef;
 char ch = 0;//用来停止输入
 Ploy q = *Head;
 Ploy p = (*Head)->next;

 if ((fp1 = fopen("ploy.txt", "r")) == NULL) {
  perror("the file ploy.txt fail to read");
  system("pause");
  exit(1);
 }
 
 while (!feof(fp1) && !ferror(fp1)) {
  fscanf(fp1, "%f%d", &coef,&exp);
  p = (Ploy)malloc(sizeof(Node));
  if (p) {
   p->coef = coef;
   p->exp = exp;
   p->next = q->next;
   q->next = p;
  }
  q = p;
  p = p->next;
 }

 Sort_and_Merge_Ploy(Head);
 printf("你输入的ploy多项式为：\noutput:");
 Print_Ploy(Head, fp);
}


void Final_Add_Ans(ptrPloy pa, ptrPloy pb, ptrPloy pc,FILE* fp)
{
 printf("即将进行相加：\n");
 system("pause");
 Add_Ploy(pa, pb, pc);
 printf("两多项式相加后的结果如下:\n");
 fprintf(fp,"两多项式相加后的结果如下:\n");
 Print_Ploy(pc,fp);
}

void Final_Sub_Ans(ptrPloy pa, ptrPloy pb, ptrPloy pc,FILE* fp)
{
 printf("即将进行相减：\n");
 system("pause");
 Sub_Ploy(pa, pb, pc);
 printf("两多项式相减后的结果如下:\n");
 fprintf(fp, "两多项式相减后的结果如下:\n");
 Print_Ploy(pc,fp);
}

void Final_Mult_Ans(ptrPloy pa, ptrPloy pb, ptrPloy pc,FILE* fp)
{
 printf("即将进行相乘：\n");
 system("pause");
 Mult_Ploy(pa, pb, pc);
 printf("两多项式相乘后的结果如下:\n");
 fprintf(fp, "两多项式相乘后的结果如下\n");
 Print_Ploy(pc,fp);
}

void Command_Ploy(void)
{
 printf("*********************************请输入多项式的操作命令********************************\n");
 printf("操作命令提醒：\n1.创建一个多项式 2.多项式赋值求和 3.多项式相加 4.多项式相减 5.多项式相乘 6.退出\n");
 printf("***************************************************************************************\n");
 printf("Cmd:");
}

测试

测试1：

 

橘子味的晚霞和少年
关注
  • 13
    点赞
  • 踩
  • 49
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
一元多项式的加法、减法、乘法
06-17
使用链表来实现单元多项式的加法、减法、乘法。其中，加法是其它运算的基础，减法：poly1-poly2=poly1+(-poly2)，乘法：poly1*poly2，可用poly1乘以poly2的每一项，相加其乘积结果。
一元稀疏多项式计算器 【 数据结构课设作业 】 带界面，无bug，可以直接运行
林深不见鹿 的博客
01-11 5054
一元稀疏多项式计算器 问题描述 设计一个一元稀疏多项式简单计算器。 基本要求 （1）输入并建立多项式。 （2）输出多项式，输出形式为整数序列：n,c1,e1,c2,e2,…,cn,en，其中n是多项式的项数，ci,ei分别是第i 项的系数和指数，序列按指数降序排列。 （3）实现多项式a和b相加，建立多项式a+b。 （4）实现多项式a和b相减，建立多项式a-b。 （5）计算多项式在x处的值。 （6）计算器的仿真界面。 测试数据 第一组： 5x^8-3.1x^11+2x 11x^9-5x^8+7 第二组:
数据结构课设（C++）——一元稀疏多项式简单计数器
m0_47471269的博客
07-27 797
（1） 输入并建立多项式 （2） 输出多项式，输出形式为整数序列：n，c1，e1，c2，e2……cn，en，其中n是多项式的项数，ci，ei分别为第i项的系数和指数。序列按指数降序排列。 （3） 多项式a和b相加，建立多项式a+b，输出相加的多项式。 （4） 多项式a和b相减，建立多项式a-b，输出相减的多项式。 用带头结点的单链表存储多项式。 测试数据： （1）(2x+5x8-3.1x11)+(7-5x8+11x9) （2） (6x-3-x+4.4x2-1.2x9)-(-6x-3+5.4x2+7.8x15
一元稀疏多项式简单计算器（C语言）含注释
m0_62925086的博客
02-22 5776
一元稀疏多项式简单计算器（C语言）含注释 问题描述 设计一个一元稀疏多项式简单计算器 基本要求 一元稀疏多项式简单计算器的基本功能是： （1）输入并建立多项式； （2）输出多项式，输出形式为整数序列：n,c1,e1,c2,e2,……,cn,en，其中n是多项式的项数，ci和ei分别是第i项的系数和指数，序列按指数降序排列； （3）多项式a和b相加，建立多项式a+b； （4）多项式a和b相减，建立多项式a-b。
数据结构实验——多项式加减
Anffen的博客
01-09 3040
问题描述 设计算法实现一元多项式的简单运算。 基本要求 （1） 输入并建立多项式; （2） 输出多项式; （3） 多项式加法 （4） 多项式减法。 问题分析 （一）算法设计思路： 建立两个带头结点的单链表储存多项式，每个结点分别有一个系数域（浮点型）、指数域（整型）、指针域（指向下一个结点）。用户输入两个多项式的每一项系数及其对应指数，储存并将其按指数升序排序。若为加法，则直接将两多项式相加，若为减法，则将第二个多项式系数依次取反后相加。输出结果多项式。 （二）使用模块及变量的说明 1
数据结构中： 一元多项式的运算（相加，相减，相乘）------用C语言 / C++来实现。 数据结构线性表的操作和应用（顺序存储）
Yskm_sir的博客
05-11 2734
线性表的操作和应用（顺序存储）。用顺序存储实现一元多项式，并进行加、减、乘运算。（5）加法运算 （6）减法运算。（1）创建顺序表 （2）初始化。（3）一元多项式赋值 （4）打印一元多项式。（2）一元多项式结构体创建版块。（4）一元多项式赋值 模块。（5）一元多项式打印 模块。（3）检查初始化版块。（6）加法运算 版块。（7）减法运算 模块。（8）乘法运算 模块。
C语言多项式加减.c
qq_63000248的博客
07-07 220
【代码】C语言多项式加减.c。
多项式加法减法和乘法源代码
05-24
用C语言建立链表实现多项式的加法、减法 和乘法的完整程序。
GuanYH_数据结构课程设计for C-一元多项式简单计算源代码
04-04
该数据结构课程设计利用C语言来实现一元多项式的简单计算，即包括多项式的加法、减法和乘法计算。
数据结构，课程设计，c语言，一元多项式计算
04-14
顺序结构、动态链表结构下的一元多项式的加法、减法、乘法的实现。 设有一元多项式Am(x)和Bn(x). Am(x)=A0+A1x1+A2x2+A3x3+&hellip; +Amxm Bn(x)=B0+B1x1+B2x2+B3x3+&hellip; +Bnxn 请实现求M(x)= Am(x)+Bn(x)、M(x)= Am(x)-...
一元稀疏多项式运算代码
12-20
分别完成二者的加法、减法、乘法运算，输出和多项式、差多项式、乘积多项式， 并求多项式在x（double型）处的值。要求： 1、分别以顺序表和单链表为存储结构实现多项式的加法和减法运算。 2、乘法运算的实现使用...
多项式的c语言算法实现（包含加、减、乘。除法还未写好）
bzqcool的专栏
10-13 1753
#include#include#includetypedef struct node{  float exof;//系数  int expn;//指数}DataNode;typedef struct Node{  DataNode data;  struct Node *next;}PolyNode,*Polynomial;typedef enum {error,ok,fail,success}
一元稀疏多项式（详解加注释）
冰月灵狐
01-26 8576
题目：    一元稀疏多项式简单计算器的基本功能是： 1.输入并建立多项式； 2.输出多项式,输出形式为整数序列：n,c1,e1,,c2,e2 …… cn,en,其中 n是多项式的项数,ci和ei分别是第i项的系数和指数,序列按指数降序排列。 3.多项式a和b相加,建立多项式a+b 4.多项式a和b相减 ,建立多项式a-b 代码如下： #include &lt;iostream&...
C语言实现两个多项式相加&相减&相乘运算
Miss Z的博客
11-15 6573
1
C语言单链表实现多项式的加法、减法、乘法
Ian_Yan的博客
07-25 5663
C语言采用单链表存储结构实现多项式的加法、减法、乘法的代码实现 #include &lt;stdio.h&gt; #include &lt;stdlib.h&gt; typedef struct polynomial{ float coef; int expn; struct polynomial *next; }polynomial; // 创建多项式，m为多项式的...
多项式的加减法以及乘法的C语言实现
热门推荐
JessicaWin
05-25 1万+
#include #include "polyn.h" void main() { Node *polyn1; Node head1; Node *polyn2; Node head2; Node *polyn3; Node head3; Node *polyn4; Node head4; polyn1 = &head1; polyn2 = &head2; polyn
【数据结构】一文了解二叉树的顺序结构（堆）
最新发布
tidal_wave的博客
05-18 724
普通的二叉树是不适合用数组来存储的，因为可能会存在大量的空间浪费。而完全二叉树更适合使用顺序结构存储。现实中我们通常把堆(一种二叉树)使用顺序结构的数组来存储，需要注意的是这里的堆和操作系统虚拟进程地址空间中的堆是两回事，一个是数据结构，一个是操作系统中管理内存的一块区域分段。以上就是今天要讲的内容，本文仅仅简单介绍了堆的使用，而堆提供了大量能使我们快速便捷地处理数据的思路。以后博主会继续介绍二叉树的其他知识，期待你的阅读。
数据结构——二叉树知识点详解！
hu_ju_hong的博客
05-15 639
数据结构二叉树概念超详细讲解！同时也是学习数据结构——堆的必修课！
用c语言写一个数据结构的一元多项式计算器实现加法减法乘法的功能
06-03
好的，以下是一个用 C 语言实现的一元多项式计算器，包括加法、减法和乘法功能。它使用链表来存储多项式，每个节点表示一个项，包括系数和指数。其中，每个节点都有一个指向下一个节点的指针。代码如下： ```c #...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

橘子味的晚霞和少年

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值