精华内容
下载资源
问答
  • 【C++】单链表实现多项式加法运算
    2021-03-14 22:53:18

    题目:

    请使用单链表实现两个多项式的加法运算,其中多项式的项按指数从高到低排列。例如3x^2-x+2输入形式为3  2  -1  1  2  0

    测试样例:

    样例1:

    输入样例:

    3  4  2  3  1  2(第一个多项式)

    -2  3  4  2  5  1  6  0(第二个多项式)

    输出样例:

    3  4  5  2  5  1  6  0求和结果)

    样例2:

    输入样例:

    3  10000  2  1

    2  100  -2  1  1  0

    输出样例:

    3  10000  2  100  1  0

    //单链表实现多项式加法
    //author:Mitchell_Donovan
    //date:2021.3.9
    #include<iostream>
    using namespace std;
    
    template<class T>
    class link
    {
    public:
    	T number, index;
    	link<T>* next;
    	link(const T numberValue, const T indexValue)
    	{
    		number = numberValue;
    		index = indexValue;
    		next = NULL;
    	}
    };
    
    template <class T>
    class linkList {
    private:
    	link<T>* head = new link<T>(0, 0);
    public:
    	linkList() {
    		head->next = NULL;
    	}
    	~linkList() {
    		link<T>* p;
    		while (head != NULL) {
    			p = head;
    			head = head->next;
    			delete p;
    		}
    	}
    	bool print();
    	bool insert(const T numberValue, const T indexValue);
    	bool add(linkList<T> a, linkList<T> b);
    };
    
    template<class T>
    bool linkList<T>::print() {
    	link<T>* p = head->next;
    	cout << "f(x)= ";
    	if (p == NULL) {
    		cout << "0" << endl;
    		return false;
    	}
    	while (p != NULL) {
    		if (p->number != 0) {
    			cout << p->number << "x^" << p->index;
    			break;
    		}
    		p = p->next;
    	}
    	p = p->next;
    	while (p != NULL) {
    		if (p->number != 0) {
    		cout << " + " << p->number << "x^" << p->index;
    		}
    		p = p->next;
    	}
    	cout << endl;
    	return true;
    }
    
    template<class T>
    bool linkList<T>::insert(const T numberValue, const T indexValue)
    {
    	link<T>* p = head;
    	link<T>* q = new link<T>(numberValue, indexValue);
    	q->next = p->next;
    	p->next = q;
    	return true;
    }
    
    template<class T>
    bool linkList<T>::add(linkList<T> a, linkList<T> b) {
    	link<T>* p = a.head->next,* q = b.head->next;
    	while (p != NULL && q != NULL) {
    		if (p->index < q->index) {
    			insert(p->number, p->index);
    			p = p->next;
    		}
    		else if (p->index > q->index) {
    			insert(q->number, q->index);
    			q = q->next;
    		}
    		else if (p->index == q->index) {
    			insert(p->number + q->number, p->index);
    			p = p->next;
    			q = q->next;
    		}
    	}
    	while (p != NULL) {
    		insert(p->number, p->index);
    		p = p->next;
    	}
    	while (q != NULL) {
    		insert(q->number, q->index);
    		q = q->next;
    	}
    	return true;
    }
    
    
    
    int main() {
    	linkList<int> La, Lb, Lc;
    	int size;
    	int number, index;
    	cout << "请输入第一个多项式的项数:" << endl;
    	cin >> size;
    	cout << "请输入各项和其指数:" << endl;
    	for (int i = 1; i <= size; i++) {
    		cin >> number >> index;
    		La.insert(number, index);
    	}
    	La.print();
    	cout << "请输入第二个多项式的项数:" << endl;
    	cin >> size;
    	cout << "请输入各项和其指数:" << endl;
    	for (int i = 1; i <= size; i++) {
    		cin >> number >> index;
    		Lb.insert(number, index);
    	}
    	Lb.print();
    	Lc.add(La, Lb);
    	Lc.print();
    }

    更多相关内容
  • 编程实现一元多项式加法运算。(要求用链表实现) 输入 第一行为一元多项式A, 以 0,0 作为输入结束; 第二行为一元多项式B, 以 0,0 作为输入结束。 输出 多项式A和多项式B的和。 样例输入 5,3 7,8 9,15 0,0 2,0 ...

    题目描述
    编程实现一元多项式的加法运算。(要求用链表实现)

    输入
    第一行为一元多项式A, 以 0,0 作为输入结束;

    第二行为一元多项式B, 以 0,0 作为输入结束。

    输出
    多项式A和多项式B的和。

    样例输入
    5,3 7,8 9,15 0,0
    2,0 6,3 -7,8 0,0

    样例输出
    2x0+11x3+9x^15

    #include<stdio.h>
    #include<malloc.h>
    typedef struct L
    {
        int cof;
        int exp;
        struct L *next;
    }Lnode;
    void init(Lnode*&L)
    {
        L=(Lnode*)malloc(sizeof(Lnode));
        Lnode *p=L,*s;
        int x,y;
        char dot;
        while(scanf("%d%c%d",&x,&dot,&y))//尾插法建链表
        {
            if(x==0&&y==0)
            {
                break;
            }
            s=(Lnode*)malloc(sizeof(Lnode));
            s->cof=x;
            s->exp=y;
            p->next=s;
            p=s;
        }
        p->next=NULL;
    }
    void Add(Lnode*&L1,Lnode*&L2)
    {
        Lnode *s,*p=L1->next,*q=L2->next,*r;
        while(p!=NULL)//遍历L1
        {
            while(q!=NULL)//遍历L2
            {
                r=q->next;
                if(q->exp==p->exp)//如果指数相等,则系数相加
                {
                    q->cof+=p->cof;
                    break;
                }else
                if(r!=NULL && (p->exp>q->exp) && (p->exp<r->exp) )
                {//若不到尾结点,p结点指数比q之前的大,比之后的小,故插在中间位置
                    s=(Lnode*)malloc(sizeof(Lnode));
                    s->cof=p->cof;
                    s->exp=p->exp;
                    q->next=s;
                    s->next=r;
                    break;
                }else
                if(r==NULL)//若到达L2的尾部,则把q(L1的结点)插在L2的尾部
                {
                    s=(Lnode*)malloc(sizeof(Lnode));
                    s->cof=p->cof;
                    s->exp=p->exp;
                    q->next=s;
                    s->next=NULL;
                    break;
                }else
                if(q==L2->next&&p->exp<q->exp)
                {//若q结点的指数比L2的初始结点的大,则插在L2的开头
                 //头插法
                    s=(Lnode*)malloc(sizeof(Lnode));
                    s->cof=p->cof;
                    s->exp=p->exp;
                    L2->next=s;
                    s->next=q;
                    break;
                }else
                q=q->next;//q向后移,遍历L2
            }
            p=p->next;//p向后移,遍历L1
            q=L2->next;//q初始化,指向L2的首结点
        }
    }
    void display(Lnode*L2)
    {
        Lnode*p=L2->next;
        while(p!=NULL)
        {
            if(p->cof!=0)
            printf("%dx^%d",p->cof,p->exp);
            p=p->next;
            if(p!=NULL&&p->cof!=0)
            {
                printf("+");
            }
    
        }
    }
    void dis(Lnode*L)
    {
        Lnode*p=L->next;
        while(p!=NULL)
        {
            printf("%d %d",p->cof,p->exp);
            p=p->next;
        }
        printf("\n");
    }
    int main()
    {
        Lnode *L1,*L2;
        init(L1);
        init(L2);//初始化两个表达式
        Add(L1,L2);//相加,相加结果放在L2上
        display(L2);//打表
    }
    
    
    展开全文
  • 多项式加法运算(链表实现)

    千次阅读 多人点赞 2021-04-24 13:09:04
    我们用链表存储一个多项式,那么该链表的每一个结点就代表多项式的某一项。所以我们的每一个结点必须包含三个信息:多项式的系数、多项式的指数以及指向下一个结点的指针。 typedef int SLTDataType;//指数、系数...

    创建结点类型

    我们用链表存储一个多项式,那么该链表的每一个结点就代表多项式的某一项。所以我们的每一个结点必须包含三个信息:多项式的系数、多项式的指数以及指向下一个结点的指针。

    typedef int SLTDataType;//指数、系数类型
    
    typedef struct SListNode
    {
    	SLTDataType coef;//系数
    	SLTDataType expon;//指数
    	struct SListNode* next;//用于存放下一个结点的地址
    }SListNode;
    

    打印多项式

    传入一个指向多项式链表的指针,遍历该链表依次打印链表内容。(一次打印一个结点)

    //打印多项式
    void SListPrint(SListNode* head)
    {
    	SListNode* cur = head;
    	if (cur)
    	{
    		printf("%dx^%d", cur->coef, cur->expon);//打印第一项
    		cur = cur->next;
    	}
    	while (cur)
    	{
    		printf("%+dx^%d", cur->coef, cur->expon);
    		cur = cur->next;
    	}
    	printf("\n");
    }
    

    注:需将第一项拿出来单独打印,因为我们不希望第一项系数的正号被打印出来(若第一项系数为正)。

    尾插

    将一个项尾插到一个多项式的后面。我们需要申请一个新结点,将要求的系数和指数赋值给这个新结点,并将新结点的指针域置空,然后尾插到目标多项式的后面。

    //创建一个新结点,返回新结点地址
    SListNode* BuySLTNode(SLTDataType coef, SLTDataType expon)
    {
    	SListNode* node = (SListNode*)malloc(sizeof(SListNode));//向新结点申请空间
    	if (node == NULL)
    	{
    		printf("malloc fail\n");
    		exit(-1);
    	}
    	node->coef = coef;//系数赋值
    	node->expon = expon;//指数赋值
    	node->next = NULL;//将新结点的指针域置空
    	return node;//返回新结点地址
    }
    //尾插
    void SListPushBack(SListNode** pHead, SLTDataType coef, SLTDataType expon)
    {
    	SListNode* newnode = BuySLTNode(coef, expon);//申请一个新结点
    	if (*pHead == NULL)//判断是否为空表
    	{
    		*pHead = newnode;//头指针直接指向新结点
    	}
    	else
    	{
    		SListNode* tail = *pHead;//接收头指针
    		while (tail->next != NULL)//若某结点的指针域为NULL,说明它是最后一个结点
    		{
    			tail = tail->next;指针指向下一个结点
    		}
    		tail->next = newnode;//让最后一个结点的指针域指向新结点
    	}
    }
    

    注:若原多项式为空,即链表为空,直接让原链表指针指向新申请的结点即可。

    插入排序

    输入的多项式可能并不是有序的,这时我们需要将多项式按指数降序排列(或按指数升序排列),以简化后续多项式的相加操作,这里我们选用插入排序算法。

    //插入排序
    SListNode* InsertSortList(SListNode* head)
    {
    	if (head == NULL || head->next == NULL)//若链表为空或链表只有一个结点,则不需排序
    		return head;
    
    	SListNode* sortHead = head;//记录排序后链表的第一个结点
    	SListNode* cur = head->next;//从待排链表的第二个结点开始排序
    	sortHead->next = NULL;//默认链表的第一个结点有序,设置其指针域为空
    	while (cur)
    	{
    		SListNode* next = cur->next;//记录当前正在排序的结点的下一个结点
    		SListNode* c = sortHead;//记录当前遍历到的有序链表的结点位置
    		SListNode* p = NULL;//记录c的前一个结点位置
    		while (c)
    		{
    			if (cur->expon > c->expon)//待插入结点的指数大于当前遍历到的有序链表的结点的指数
    			{
    				break;
    			}
    			else//待插入结点与有序链表中的下一个结点比较
    			{
    				p = c;
    				c = c->next;
    			}
    		}
    		if (p == NULL)//将待插入结点插入到有序链表的第一个位置
    		{
    			cur->next = sortHead;
    			sortHead = cur;
    		}
    		else//将待插入结点插入到p和c之间
    		{
    			cur->next = c;
    			p->next = cur;
    		}
    		cur = next;//插入下一个待插入结点
    	}
    	return sortHead;//返回排列好的链表
    }
    

    多项式相加

    从两个待相加的多项式的表头开始,比较两个结点的指数大小,若相同,则将两个结点的系数相加得到新的系数,申请一个新结点(结点的系数为新得到的系数,指数与这两个结点的指数相同)尾插到新链表的后面即可。若两个结点的指数不相同,则申请一个新结点(新结点的系数和指数与两个结点中指数较大的结点相同)尾插到新链表后面即可。

    //比较两个结点的指数大小
    int Compare(SLTDataType e1, SLTDataType e2)
    {
    	if (e1 > e2)
    		return 1;
    	else if (e1 < e2)
    		return -1;
    	else
    		return 0;
    }
    //多项式相加
    SListNode* PolyAdd(SListNode* P1, SListNode* P2)
    {
    	SListNode* front = NULL;//相加后的链表的头指针
    	while (P1&&P2)
    	{
    		switch (Compare(P1->expon, P2->expon))//比较指数
    		{
    		case 1:
    			SListPushBack(&front, P1->coef, P1->expon);
    			P1 = P1->next;
    			break;
    		case -1:
    			SListPushBack(&front, P2->coef, P2->expon);
    			P2 = P2->next;
    			break;
    		case 0:
    			SLTDataType sum = P1->coef + P2->coef;
    			if (sum)
    				SListPushBack(&front, sum, P1->expon);
    			P1 = P1->next;
    			P2 = P2->next;
    			break;
    		}
    	}
    	while (P1)//将P1剩余项尾插到链表后面
    	{
    		SListPushBack(&front, P1->coef, P1->expon);
    		P1 = P1->next;
    	}
    	while (P2)//将P2剩余项尾插到链表后面
    	{
    		SListPushBack(&front, P2->coef, P2->expon);
    		P2 = P2->next;
    	}
    	return front;//返回新链表
    }
    

    可以对照下图进行逻辑分析:
    在这里插入图片描述
    注:当两个指数相同的结点的系数相加为0时,不必申请新结点插入新链表。

    代码总览 + 结果展示

    #include <stdio.h>
    #include <stdlib.h>
    #include <assert.h>
    
    typedef int SLTDataType;//指数、系数类型
    
    typedef struct SListNode
    {
    	SLTDataType coef;//系数
    	SLTDataType expon;//指数
    	struct SListNode* next;//用于存放下一个结点的地址
    }SListNode;
    
    //打印多项式
    void SListPrint(SListNode* head)
    {
    	SListNode* cur = head;
    	if (cur)
    	{
    		printf("%dx^%d", cur->coef, cur->expon);//打印第一项
    		cur = cur->next;
    	}
    	while (cur)
    	{
    		printf("%+dx^%d", cur->coef, cur->expon);
    		cur = cur->next;
    	}
    	printf("\n");
    }
    //创建一个新结点,返回新结点地址
    SListNode* BuySLTNode(SLTDataType coef, SLTDataType expon)
    {
    	SListNode* node = (SListNode*)malloc(sizeof(SListNode));//向新结点申请空间
    	if (node == NULL)
    	{
    		printf("malloc fail\n");
    		exit(-1);
    	}
    	node->coef = coef;//系数赋值
    	node->expon = expon;//指数赋值
    	node->next = NULL;//将新结点的指针域置空
    	return node;//返回新结点地址
    }
    //尾插
    void SListPushBack(SListNode** pHead, SLTDataType coef, SLTDataType expon)
    {
    	SListNode* newnode = BuySLTNode(coef, expon);//申请一个新结点
    	if (*pHead == NULL)//判断是否为空表
    	{
    		*pHead = newnode;//头指针直接指向新结点
    	}
    	else
    	{
    		SListNode* tail = *pHead;//接收头指针
    		while (tail->next != NULL)//若某结点的指针域为NULL,说明它是最后一个结点
    		{
    			tail = tail->next;指针指向下一个结点
    		}
    		tail->next = newnode;//让最后一个结点的指针域指向新结点
    	}
    }
    //选择排序
    SListNode* InsertSortList(SListNode* head)
    {
    	if (head == NULL || head->next == NULL)//若链表为空或链表只有一个结点,则不需排序
    		return head;
    
    	SListNode* sortHead = head;//记录排序后链表的第一个结点
    	SListNode* cur = head->next;//从待排链表的第二个结点开始排序
    	sortHead->next = NULL;//默认链表的第一个结点有序,设置其指针域为空
    	while (cur)
    	{
    		SListNode* next = cur->next;//记录当前正在排序的结点的下一个结点
    		SListNode* c = sortHead;//记录当前遍历到的有序链表的结点位置
    		SListNode* p = NULL;//记录c的前一个结点位置
    		while (c)
    		{
    			if (cur->expon > c->expon)//待插入结点的指数大于当前遍历到的有序链表的结点的指数
    			{
    				break;
    			}
    			else//待插入结点与有序链表中的下一个结点比较
    			{
    				p = c;
    				c = c->next;
    			}
    		}
    		if (p == NULL)//将待插入结点插入到有序链表的第一个位置
    		{
    			cur->next = sortHead;
    			sortHead = cur;
    		}
    		else//将待插入结点插入到p和c之间
    		{
    			cur->next = c;
    			p->next = cur;
    		}
    		cur = next;//插入下一个待插入结点
    	}
    	return sortHead;//返回排列好的链表
    }
    //比较两个结点的指数大小
    int Compare(SLTDataType e1, SLTDataType e2)
    {
    	if (e1 > e2)
    		return 1;
    	else if (e1 < e2)
    		return -1;
    	else
    		return 0;
    }
    //多项式相加
    SListNode* PolyAdd(SListNode* P1, SListNode* P2)
    {
    	SListNode* front = NULL;//相加后的链表的头指针
    	while (P1&&P2)
    	{
    		switch (Compare(P1->expon, P2->expon))//比较指数
    		{
    		case 1:
    			SListPushBack(&front, P1->coef, P1->expon);
    			P1 = P1->next;
    			break;
    		case -1:
    			SListPushBack(&front, P2->coef, P2->expon);
    			P2 = P2->next;
    			break;
    		case 0:
    			SLTDataType sum = P1->coef + P2->coef;
    			if (sum)
    				SListPushBack(&front, sum, P1->expon);
    			P1 = P1->next;
    			P2 = P2->next;
    			break;
    		}
    	}
    	while (P1)//将P1剩余项尾插到链表后面
    	{
    		SListPushBack(&front, P1->coef, P1->expon);
    		P1 = P1->next;
    	}
    	while (P2)//将P2剩余项尾插到链表后面
    	{
    		SListPushBack(&front, P2->coef, P2->expon);
    		P2 = P2->next;
    	}
    	return front;//返回新链表
    }
    
    int main()
    {
    	SListNode* P1 = NULL;//存放第一个表达式数据的链表
    	SListNode* P2 = NULL;//存放第二个表达式数据的链表
    	SLTDataType coef, expon;
    	//1.输入两个多项式
    	int count = 0;
    	printf("请输入第一个多项式的项数:>");
    	scanf("%d", &count);
    	printf("请输入第一个多项式:>");
    	int i = 0;
    	for (i = 0; i < count; i++)
    	{
    		scanf("%dx^%d", &coef, &expon);
    		SListPushBack(&P1, coef, expon);
    	}
    	printf("请输入第二个多项式的项数:>");
    	scanf("%d", &count);
    	printf("请输入第二个多项式:>");
    	for (i = 0; i < count; i++)
    	{
    		scanf("%dx^%d", &coef, &expon);
    		SListPushBack(&P2, coef, expon);
    	}
    	//2.分别将两个多项式按指数降序排列
    	SListNode* SortP1 = InsertSortList(P1);//按指数排序第一个多项式
    	SListNode* SortP2 = InsertSortList(P2);//按指数排序第二个多项式
    	printf("第一个多项式按指数降序排列为:>");
    	SListPrint(SortP1);
    	printf("第二个多项式按指数降序排列为:>");
    	SListPrint(SortP2);
    	//3.将两个多项式相加
    	SListNode* PolyAddHead = PolyAdd(SortP1, SortP2);//将两个多项式相加
    	printf("将两个多项式相加之后的结果为:>");
    	SListPrint(PolyAddHead);
    	return 0;
    }
    

    在这里插入图片描述
    注意:多项式输入时,每一项的输入格式需相同,均为:系数x^指数。

    展开全文
  • C语言实现一元多项式加法运算

    千次阅读 2020-10-08 23:12:11
    回到正题,一元多项式加法运算,大概是这样的: 知道怎么操作了之后就来看看如何储存一元多项式叭: 很明显为了方便操作,而且每一项都含有 系数(coefficient)、指数 (index),为了避免S形一元多项式带来的...

    说到一元多项式相加,相信很多小伙伴都不会陌生,甚至 “合并同类项” 已经要脱口而出了(因为上节课本人就是这样的哈哈~)
    回到正题,一元多项式的加法运算,大概是这样的:

    在这里插入图片描述
    知道怎么操作了之后就来看看如何储存一元多项式叭:
    很明显为了方便操作,而且每一项都含有 系数(coefficient)、指数 (index),为了避免S形一元多项式带来的空间浪费,我们采用链式结构储存一元多项式,本题中采用普通的单链表进行储存(不需要方便访问头尾结点时可以不用循环链表)

    话不多说,先整两个一元多项式看看↓
    老规矩,数据类型和结构体定义先给出来
    PNode、LinkList分别表示结点和链表,Datatype即int,coe为系数,ind为指数

    //重定义类型和声明函数
    typedef struct Node* PNode;
    typedef struct Node* LinkList;
    typedef int Datatype;
    struct Node
    {
    	Datatype      coe;
    	Datatype      ind;
    	struct Node* next;
    };
    PNode Add_POLYA(LinkList head1, LinkList head2);
    
    

    构建一元多项式:
    ps:当接收到的系数和指数同时为0时停止输入,即一个多项式的结束

    LinkList setnulllist_link()
    {
    	LinkList head = (LinkList)malloc(sizeof(struct Node));
    	if (head != NULL) head->next = NULL;
    	else printf("alloc failure");
    	return head;
    }
    
    void createlist_tail(struct Node* head)
    {
    	PNode p = NULL;
    	PNode q = head;
    	Datatype coe;
    	Datatype ind;
    	printf("please input coefficient and index:\n");
    	scanf_s("%d,%d", &coe, &ind);
    	while ((coe != 0) || (ind != 0))
    	{
    		p = (struct Node*)malloc(sizeof(struct Node));
    		p->coe = coe;
    		p->ind = ind;
    		p->next = NULL;
    		q->next = p;
    		q = p;
    		scanf_s("%d,%d", &coe, &ind);
    	}
    	return;
    }
    

    再来看多项式相加函数:
    ps:两个多项式的和最后储存在第一个多项式head1中,不喜欢的小伙伴也可以自行调整嗷~

    PNode Add_POLYA(LinkList head1, LinkList head2)
    {
    	PNode pre = NULL, p = NULL, qre = NULL, q = NULL;
    	pre = head1;
    	p = head1->next;
    	qre = head2;
    	q = head2->next;
    	if (qre == NULL)
    	{
    		return head1;
    	}
    	while (p != NULL)
    	{
    		if (q == NULL)
    		{
    			return head1;
    		}
    		//两个项指数相等时
    		if (p->ind == q->ind)
    		{
    			p->coe = q->coe + p->coe;
    			//两项和为0时
    			if (p->coe == 0)
    			{
    				pre->next = p->next;
    				free(p);
    				p = pre->next;
    				qre->next = q->next;
    				free(q);
    				q = qre->next;
    			}
    			else {
    				pre = p;
    				p = p->next;
    				qre->next = q->next;
    				free(q);
    				q = qre->next;
    			}
    		}
    		//多项式1的项的指数大于多项式2的项时
    		else if (p->ind > q->ind)
    		{
    			qre->next = q->next;
    			q->next = p;
    			pre->next = q;
    			pre = q;
    			q = qre->next;
    		}
    		//多项式2的项指数大小在多项式1的项与下一项中间时
    		else if (q->ind > p->ind && q->ind < (p->next)->ind)
    		{
    			qre->next = q->next;
    			pre = p;
    			p = p->next;
    			q->next = p;
    			pre->next = q;
    			pre = q;
    			q = qre->next;
    		}
    		else if (q->ind > p->ind && q->ind >= (p->next)->ind)
    		{
    			pre = p;
    			p = p->next;
    		}
    	}
    
    	return head1;
    }
    

    需要注意的就是两个项的指数大小问题(注意看上方的注释嗷~)
    最后来看整体代码与运行结果:

    //链式存储实现多项式加法
    #include<stdio.h>
    #include<stdlib.h> 
    
    //重定义类型和声明函数
    typedef struct Node* PNode;
    typedef struct Node* LinkList;
    typedef int Datatype;
    struct Node
    {
    	Datatype      coe;
    	Datatype      ind;
    	struct Node* next;
    };
    PNode Add_POLYA(LinkList head1, LinkList head2);
    
    LinkList setnulllist_link()
    {
    	LinkList head = (LinkList)malloc(sizeof(struct Node));
    	if (head != NULL) head->next = NULL;
    	else printf("alloc failure");
    	return head;
    }
    
    void createlist_tail(struct Node* head)
    {
    	PNode p = NULL;
    	PNode q = head;
    	Datatype coe;
    	Datatype ind;
    	printf("please input coefficient and index:\n");
    	scanf_s("%d,%d", &coe, &ind);
    	while ((coe != 0) || (ind != 0))
    	{
    		p = (struct Node*)malloc(sizeof(struct Node));
    		p->coe = coe;
    		p->ind = ind;
    		p->next = NULL;
    		q->next = p;
    		q = p;
    		scanf_s("%d,%d", &coe, &ind);
    	}
    	return;
    }
    
    void print(LinkList head)
    {
    	PNode  p = head->next;
    	while (p != NULL)
    	{
    		if (p->next != NULL) {
    			printf("%d,%d ", p->coe, p->ind);
    		}
    		else {
    			printf("%d,%d ", p->coe, p->ind);
    		}
    		p = p->next;
    	}
    	return;
    }
    
    void destorylist_link(LinkList head)
    {
    	PNode  pre = head;
    	PNode p = pre->next;
    	while (p)
    	{
    		free(pre);
    		pre = p;
    		p = pre->next;
    	}
    	free(pre);
    	return;
    }
    
    int main()
    {
    	LinkList head1 = NULL, head2 = NULL;
    	head1 = setnulllist_link();
    	head2 = setnulllist_link();
    	createlist_tail(head1);
    	createlist_tail(head2);
    	Add_POLYA(head1, head2);
    	print(head1);
    	destorylist_link(head1);
    	system("pause");
    	return 0;
    }
    
    PNode Add_POLYA(LinkList head1, LinkList head2)
    {
    	PNode pre = NULL, p = NULL, qre = NULL, q = NULL;
    	pre = head1;
    	p = head1->next;
    	qre = head2;
    	q = head2->next;
    	if (qre == NULL)
    	{
    		return head1;
    	}
    	while (p != NULL)
    	{
    		if (q == NULL)
    		{
    			return head1;
    		}
    		//两项和为0时
    		if (p->ind == q->ind)
    		{
    			p->coe = q->coe + p->coe;
    			if (p->coe == 0)
    			{
    				pre->next = p->next;
    				free(p);
    				p = pre->next;
    				qre->next = q->next;
    				free(q);
    				q = qre->next;
    			}
    			else {
    				pre = p;
    				p = p->next;
    				qre->next = q->next;
    				free(q);
    				q = qre->next;
    			}
    		}
    		//多项式1的项的指数大于多项式2的项时
    		else if (p->ind > q->ind)
    		{
    			qre->next = q->next;
    			q->next = p;
    			pre->next = q;
    			pre = q;
    			q = qre->next;
    		}
    		//多项式2的项指数大小在多项式1的项与下一项中间时
    		else if (q->ind > p->ind && q->ind < (p->next)->ind)
    		{
    			qre->next = q->next;
    			pre = p;
    			p = p->next;
    			q->next = p;
    			pre->next = q;
    			pre = q;
    			q = qre->next;
    		}
    		else if (q->ind > p->ind && q->ind >= (p->next)->ind)
    		{
    			pre = p;
    			p = p->next;
    		}
    	}
    
    	return head1;
    }
    

    运行结果:

    在这里插入图片描述
    当然可能有小伙伴觉得这样不好看,这哪里是一个真正的一元多项式啊!
    没办法,为了过平台上的测试,呜呜~

    大家如果想要美观的话可以自行修改代码中的 print 函数嗷,我就不改啦
    最后说一下,要是copy本篇代码来过实验的话,记得查看print 函数哈,不然有可能会出现格式错误的问题。

    编译器:visual studio 2019,使用其他编译器的小伙伴们记得修改相关函数嗷~

    展开全文
  • 数据结构—一元多项式加法运算 采用不带头结点的单向链表,按照指数递减的顺序排列各项。 定义结点: struct PolyNode{ int coef;//系数 int expon;//指数 struct PolyNode *link;//指向下一结点的指针 }; ...
  • 数据结构实验报告 实验名称多项式加减法 学号1200310419 姓名林强 实验日期2015.5.05 一实验目的 通过实现多项式的加减法对链表有更深入的了解 二实验具体内容 1实验题目1 1题目设计一一元稀疏多项式简单的加减法...
  • 设计程序,输入两个一元稀疏多项式, 分别完成二者的加法、减法、乘法运算,输出和多项式、差多项式、乘积多项式, 并求多项式在x(double型)处的值。要求: 1、分别以顺序表和单链表为存储结构实现多项式加法和...
  • C语言链表应用:一元多项式加法运算 首先科普一下线性表的相关知识。线性表,即由n性质相同的数据元素组成的有序序列。线性表是最基础的线性结构,也是最基本的数据结构形式。因此学好线性表,也是学习其余数据...
  • 【C++】顺序表实现多项式加法运算

    千次阅读 2021-03-14 22:50:03
    请使用顺序表实现两个多项式加法运算,其中多项式的项按指数从高到低排列。例如3x^2-x+2输入形式为32-1120。 测试样例: 样例1: 输入样例: 342312(第一个多项式) -23425160(第二个多项式) 输出样例: ...
  • 数据结构—— 一元多项式加法运算

    万次阅读 多人点赞 2019-09-24 12:01:56
    设Pn(x)和Qn(x)分别为两个一元多项式,请求出两个一元多项式加法运算的结果,要求元素按照多项式的次数递减的次序排列。 1.问题分析 需求:实现两个一元多项式加法运算。 实现功能:①通过键盘接收输入的整数...
  • #include> #include> #include> typedef int ElemType; /* 单项链表的声明 */ typedef struct PolynNode{ int coef; // 系数 int expn; // 指数 struct PolynNode... /* 正位序 (插在表尾 )输入 n 元素的值建立带表头
  • 基于C++与链表的两个一元多项式的基本运算加法、减法、 乘法和求导运算
  • 最开始,p1、p2分别指向两个多项式的第一个结点: p1所指向的指数5>p2指向的指数4,把这一项复制到结果多项式中,然后p1指针向后挪: p1指向的指数与p2指向的指数相等,那么系数相加后,再放入结果多项式中,...
  • C语言实现一元多项式加法运算(链表)

    千次阅读 多人点赞 2019-10-05 21:26:25
    C语言实现一元多项式加法运算(链表) 完成如下操作: ①输入并建立一元稀疏多项式;(输入格式自定) 例如:4 - 12x3 + 123x5 - 80x10 ②输出所建立的一元多项式;(输出格式自定) 例如:12 - 3x + x3 + 230x12 ③...
  • C语言实现单链表方式的一元多项式加法
  • 一元多项式加法运算的实现

    千次阅读 2018-04-13 12:26:15
    编程实现一元多项式加法运算。(要求用链表实现)输入第一一元多项式A; 第二一元多项式B。 以(0,0)作为输入结束。输出多项式A和多项式B的和。样例输入5,3 7,8 9,15 0,0 2,0 6,3 -7,8 0,0样例输出2x^0+11x^...
  • PAGE PAGE # / 6 #i nclude<stdio.h> #i nclude<stdlib.h> #i nclude<malloc.h> typedef int ElemType; /*单项链表的声明*/ typedef struct PolynNode{ int coef; // 系数 int expn; // 指数 struct PolynN ode *n ...
  • //count等于2的时候表明读入了两个多项式,跳出循环 for(int i = a.length-1; i >1; i--){//循环输入各项 if(a[i]!=0){ //指数为0的不输出 System.out.print(a[i]+"x"+i+"+"); } } if(a[1]!=0){//增加a[1]项的系数...
  • 《数据结构课程设计—一元多项式加法、减法、乘法运算的实现》由会员分享,可在线阅读,更多相关《数据结构课程设计—一元多项式加法、减法、乘法运算的实现(20页珍藏版)》请在人人文库网上搜索。1、1.一元多项式...
  • 两个多项式的相加运算

    千次阅读 2021-04-09 10:30:13
    两个多项式的相加运算 目的:掌握线性表的应用和有序单链表的二路归并算法设计。 内容:用单链表储存一元多项式,并实现两个多项式的相加运算。 思路:用结点存储系数和指数,遇到指数相同的结点就使其系数相加,...
  • 基本要求: (1)实现循环单链表的初始化,求元素个数,插入、...用函数void Creat(SLNodehead)创造两个多项式,存入两个循环单链表中,再利用void AddPoly(SLNodep,SLNodeq,SLNodeL)将两个多项式相加。 模块划分:...
  • struct PNode *addPoly(PNode *L1,PNode *L2) //实现多项式加法运算 { int sum; struct PNode *p1,*p2,*p3,*r; p3=p1; p1=p1->next; p2=p2->next; while(p1&&p2) { if(p1->expn==p2->expn) {...
  • 输入:第一一元多项式A; 第二一元多项式B。 以(0,0)作为输入结束。 输出:多项式A和多项式B的和。 样例输入 5,3 7,8 9,15 0,0 2,0 6,3 -7,8 0,0 样例输出 2x^0+11x^3+9x^15 #include <stdio.h&...
  • 数据结构——一元多项式加法、减法、乘法运算的实现,可以直接使用
  • 输入在第一行给出第一个多项式POLYA的系数和指数,并以0,0 结束第一个多项式的输入; 在第二行出第一个多项式POLYB的系数和指数,并以0,0 结束第一个多项式的输入。 输出格式: 对每一组输入,在一行中输出POLYA+...
  • 用链表实现的两个多项式运算,参考数据结构书
  • 完美的数据结构大作业之选。C语言+链表 实现。不用提前知道多项式项数,可以自动排序,可以合并同类项,可以进行加法、乘法运算。VS环境可运行,其他编程软件找到cpp复制粘贴即可
  • 链表结构实现多项式的相加主要思路:相同指数的项相加,其余的拷贝。... *多项式加法运算实现 * Polynomial是存放多项式的每项的节点:指数和系数及指向下一项的节点 */ class Polynomial{ i...
  • 用链表实现两个多项式相加的C语言源代码,两个多项式相加时,同类项的系数相加,无同类项的系数保持不变,想家完后再按升幂排序,结果放回链表中。是数据结构的作业,改编了网上的代码,运行结果正确。
  • 1:多项式加法--C语言实现

    千次阅读 2020-04-12 10:14:55
    我们经常遇到两多项式相加的情况,在这里,我们就需要用程序来模拟实现把两个多项式相加到一起。首先,我们会有两个多项式,每个多项式是独立的一行,每个多项式由系数、幂数这样的多个整数对来表示。 如多项式2x20-...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 7,702
精华内容 3,080
关键字:

两个多项式的加法运算