数据结构之利用单向链表实现多项式加法和乘法

  在《数据结构与算法分析--c语言描述》一书中,作者指出了使用单向链表作为实现多项式的方法。但是没有给出具体实现。下面自己对其进行实现。只考虑功能。对其他细节不暂时不考虑。程序完成两个功能,使用单向链表完成多项式的加法和乘法。首先看加法,解决加法问题的思想在于对表示进行操作的两个链表表示的多项式按照指数递减的结构排列,每个节点的数据域存储着多项式某一项的系数(Coefficient)和指数(Exponent),还有一个指向后继节点的指针。节点的实现如下:

1 typedef struct Node* PtrToNode;
2 struct Node
3 {
4     int Coefficient;
5     int Exponent;
6     PtrToNode Next;
7 };

为多项式定义以下操作:

 1 #ifndef POLY_H_
 2 #define POLY_H_
 3
 4 typedef struct Node* PtrToNode;
 5 typedef PtrToNode Polynomial;
 6
 7 Polynomial CreatePoly();
 8 void Insert(int Coe,int Exp,Polynomial P);
 9 Polynomial AddPoly(Polynomial P1,Polynomial P2);
10 Polynomial MultiPoly(Polynomial P1,Polynomial P2);
11 void PrintPoly(Polynomial P);
12
13 #endif

下面是每个函数的实现:

  1 #include<stdlib.h>
  2 #include<stdio.h>
  3 typedef struct Node* PtrToNode;
  4 struct Node
  5 {
  6     int Coefficient;
  7     int Exponent;
  8     PtrToNode Next;
  9 };
 10
 11 typedef PtrToNode Polynomial;
 12
 13
 14 Polynomial CreatePoly()
 15 {
 16     Polynomial P = malloc(sizeof(struct Node));
 17     P->Next = NULL;
 18     return P;
 19 }
 20
 21 void Insert(int Coe,int Exp,Polynomial P)
 22 {
 23     PtrToNode  Temp = malloc(sizeof(struct Node));
 24     Temp->Coefficient = Coe;
 25     Temp->Exponent = Exp;
 26     PtrToNode Pt = P;
 27
 28     while(Pt->Next != NULL && Exp < Pt->Next->Exponent)
 29     {
 30         Pt= Pt->Next;
 31     }
 32     Temp->Next = Pt->Next;
 33     Pt->Next = Temp;
 34 }
 35
 36 void PrintPoly(Polynomial P)
 37 {
 38     PtrToNode Pt = P->Next;
 39     while(Pt!= NULL)
 40     {
 41         printf("Coe: %d,Exp: %d   ",Pt->Coefficient,Pt->Exponent);
 42         Pt = Pt->Next;
 43     }
 44 }
 45
 46 Polynomial AddPoly(Polynomial P1,Polynomial P2)
 47 {
 48     Polynomial Pt1,Pt2,PA,Pt;
 49     Pt1 = P1->Next;
 50     Pt2 = P2->Next;
 51     PA = CreatePoly();
 52     Pt = PA;
 53     while(Pt2 != NULL && Pt1 != NULL)
 54     {
 55         Polynomial Tmp = malloc(sizeof(struct Node));
 56         Tmp->Next = NULL;
 57         if(Pt1->Exponent > Pt2->Exponent)
 58         {
 59             Tmp->Coefficient = Pt1->Coefficient;
 60             Tmp->Exponent = Pt1->Exponent;
 61             Pt1 = Pt1->Next;
 62         }
 63         else if(Pt1->Exponent < Pt2->Exponent)
 64         {
 65             Tmp->Coefficient = Pt2->Coefficient;
 66             Tmp->Exponent = Pt2->Exponent;
 67             Pt2 = Pt2->Next;
 68         }
 69         else
 70         {
 71             Tmp->Coefficient = Pt1->Coefficient + Pt2->Coefficient;
 72             Tmp->Exponent = Pt2->Exponent;
 73             Pt1  = Pt1->Next;
 74             Pt2  = Pt2->Next;
 75         }
 76         Pt->Next = Tmp;
 77         Pt = Pt->Next;
 78     }
 79
 80     if(Pt1 == NULL)
 81     {
 82         while(Pt2 != NULL)
 83         {
 84             Polynomial Tmp = malloc(sizeof(struct Node));
 85             Tmp->Coefficient = Pt2->Coefficient;
 86             Tmp->Exponent = Pt2->Exponent;
 87             Pt->Next = Tmp;
 88             Pt = Pt->Next;
 89             Pt->Next = NULL;
 90             Pt2 = Pt2->Next;
 91         }
 92     }
 93
 94     if(Pt2 == NULL)
 95     {
 96         while(Pt1 != NULL)
 97         {
 98             Polynomial Tmp = malloc(sizeof(struct Node));
 99             Tmp->Coefficient = Pt1->Coefficient;
100             Tmp->Exponent = Pt1->Exponent;
101             Pt->Next = Tmp;
102             Pt = Pt->Next;
103             Pt->Next = NULL;
104             Pt1 = Pt1->Next;
105         }
106     }
107
108     return PA;
109 }
110
111
112 Polynomial MultiPoly(Polynomial P1,Polynomial P2)
113 {
114     Polynomial Pt1,P;
115     P = CreatePoly();
116     Pt1 = P1->Next;
117     while(Pt1 != NULL)
118     {
119         Polynomial  TmpList = CreatePoly();
120         Polynomial  Tp = TmpList;
121         Polynomial Pt2 = P2->Next;
122         while(Pt2 != NULL)
123         {
124             Polynomial TmNode = malloc(sizeof(struct Node));
125             TmNode->Exponent = (Pt1->Exponent) + (Pt2->Exponent);
126             TmNode->Coefficient = (Pt1->Coefficient) * (Pt2->Coefficient);
127             Tp->Next = TmNode;
128             Tp = Tp->Next;
129             Tp->Next = NULL;
130             Pt2 = Pt2->Next;
131         }
132
133         P = AddPoly(P,TmpList);
134
135         Pt1=Pt1->Next;
136     }
137     return P;
138 }

其中加法函数的计算思想是:用两个移动指针分别指向两个链表的第一个数据节点,比较两个节点中指数的大小,如果某个节点大,则将该节点复制出来,加入结果链表,如果相等,则对系数进行相加,指数不变进行复制,加入结果链表,如果某个链表先扫描完,将另一个没有扫描结束的链表复制到结果链表的后面。使用流程图表示:

以上即为加法运算的流程图。

乘法运算的流程是:使用嵌套的while循环,使链表1的每个节点都和链表2的每个节点相乘,指数相加,系数相乘,将结果保存在一个新节点中,在链表2的每次遍历中创建一个临时链表,将计算结果保存在临时链表中,内层每循环结束一次,将临时链表和要返回的链表相加一次,这样总共相加的次数是外层循环的次数。

某种程度上将乘法运算分解成了加法运算。

时间: 2024-10-09 01:21:48

数据结构之利用单向链表实现多项式加法和乘法的相关文章

单向链表实现多项式加和乘--自己写数据结构

用单项链表实现多项式数据结构和代码如下(由于时间原因多项式乘法的函数没用实现,读者可以在自己完善): 存放结构体的头文件polylist.h #ifndef _H_POLYLIST_ #define _H_POLYLIST_ typedef struct _Poly_Node { int ratio; //系数 int power; //幂 struct _Poly_Node* next; }Node,*pNode; typedef struct _Poly_List { struct _Pol

[DataStructure]多项式加法与乘法--B.链表存储(适用于零元系数多的多项式)

数据结构大作业…… 发出来大家乐呵乐呵…… 一.问题描述 给出N个多项式,求他们的和与积 二.解题报告 基本思想:加法和乘法都是把得数项直接链接在链表后面,最后统一做一个Merge&Sort工作即可.方便又快捷. (1)建立存储结构 1 struct _Poly 2 { 3 int factor;//系数 4 int Index;//幂 5 struct _Poly* next;//下一节点 6 }; 7 _Poly* poly[MAXTIMES+1]; 8 int Sum[MAXTIMES+1

文章分享:简单数据结构学习:单向链表

文章分享:简单数据结构学习:单向链表:https://www.textarea.com/aprikyb/jiandan-shujujiegou-xuexi-danxiang-lianbiao-252/

17、蛤蟆的数据结构笔记之十七链表实现多项式

17.蛤蟆的数据结构笔记之十七链表实现多项式 本篇名言:"人生不是一种享乐,而是一桩十分沉重的工作."列夫托尔斯泰. 栈的应用在上面中基本覆盖了很多,接下去我们来补充下链表在多项式实现中的例子. 欢迎转载,转载请标明出处:http://blog.csdn.net/notbaron/article/details/46653857 1.  多项式 这个问题是符号多项式的处理问题,已经成为表处理中的一个经典例子.把每项表示为一个结点,该结点包括系数域.指数域和指向下一项的指针.类型申明如下

[DataStructure]多项式加法与乘法--A.数组存储(适用于零元系数少的多项式)

数据结构大作业…… 发出来大家乐呵乐呵…… 一.问题描述 给出N个多项式,求他们的和与积 二.解题报告 (1)建立存储结构 1 struct _Poly 2 { 3 double Data[MAXTIMES+1]; 4 int Times; 5 }; 6 struct _Poly Poly[N+1]; (2)主程序架构 1 int main() 2 { 3 int Sum; 4 cout<<"请输入要做运算的多项式数量"<<endl; 5 cin>>

数据结构与算法-单向链表

概述 由于最近在工作中需要用到树形结构来解决一些问题,所以萌生了系统学习“数据结构和算法”的想法,于是乎从最简单的表结构开始.由于数组是最简单的表结构的实现,也是各个编程语言内置的数据类型,所以不做更多的记录.表结构中以下实现打算学习: LinkedList Stack Queue HashTable Dictionary 本篇为学习数据结构的第一篇随笔,从最简单的单向链表开始吧. 实现(C#) 平台:dotNet Core 1.0, C# IDE:VSCode 如果考虑算法复用的话,可以实现泛

Snail—数据结构学习之单向链表

// 定义链表的数据结构 typedef struct _LINK_NODE{ int data; struct _LINK_NODE * next; }LINK_NODE; //创建一个单向链表 LINK_NODE * create(){ int inputFlag = 1,value; LINK_NODE *head,*p,*s; head = (LINK_NODE *)malloc(sizeof(LINK_NODE)); p = head; while (inputFlag) { prin

数据结构——Java实现单向链表

结点类: 1 /** 2 * @author zhengbinMac 3 * 一个OnelinkNode类的对象只表示链表中的一个结点,通过成员变量next的自引用方式实现线性表中各数据元素的逻辑关系. 4 */ 5 public class OnelinkNode { 6 // 保存结点的值 7 public int data; 8 // 保存后继结点的引用 9 public OnelinkNode next; 10 // 构造值为k的结点 11 public OnelinkNode(int

PTA 6-14 用单向链表完成多项式运算 (35 分)

输入两个多项式,计算它们的加.减及乘法, 将计算结果输出到屏幕上. 1) 输入:从键盘分两行分别输入两个多项式数据,每个多项式输入格式如下: n a1 m1 a2 m2 a3 m3 . .. ai mi.... an mn 其中n为多项式系数为非零的项数,ai为系数,mi为指数, 它们都是整数,该输入数据所表达的多项式意义为(其中符号^表示幂次): a1x^m1 + a2x^m2 + a3x^m3 + ...... + an x^mn 2)输出:先输出参与运算的两个多项式, 然后输出它们的运算结