两个一元多项式相加（链表 || 顺序表实现）

最新推荐文章于 2023-10-01 18:03:31 发布
最新推荐文章于 2023-10-01 18:03:31 发布
阅读量1.3w 收藏 56
点赞数 4
分类专栏： 数据结构 文章标签： 数据结构 多项式相加
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mowenwen_/article/details/48682987
版权

顺序表实现：

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <map>
using namespace std;
#define maxsize 1000
struct Data
{
    double coef;
	int exp;
};
struct List
{
	Data* elem;
	int length;
};
char s[100];
map <int, int> m;
bool cmp(Data a, Data  b)
{
	return a.exp < b.exp;
}
void InitList(List &L)
{
    L.elem = (Data* )new Data[maxsize];
    L.length = 0;
}
void Derivative(int len, List L)
{
    int n = 1,flag = 0;
    for(int i = 0;i < len;i ++)
    {
        double coef = L.elem[i].coef;
        int exp = L.elem[i].exp;
         if(exp == 0)
        {
            coef = 0;
        }
        else
        {
            coef *= exp;
            exp --;
        }
         if(fabs(coef) < 1e-6)
            continue;
         else
         {
            flag = 1;
            if(n != 1 && coef > 0)
                printf("+");
            if(exp == 0)
                printf("%g", coef);
            else if(coef!= 1 && exp != 0 && coef != -1)
            {
                if(exp == 1)
                    printf("%gx",coef);
                else
                    printf("%gx^%d",coef, exp);
            }
            else if(coef == 1)
            {
                if(exp == 1)
                    printf("x");
                else
                    printf("x^%d",exp);
            }
            else if(coef == -1)
            {
                if(exp == 1)
                    printf("-x");
                else
                    printf("-x^%d",exp);
            }
            n ++;
        }
    }
    if(!flag) printf("0");
    printf("\n");
}
int main()
{
	freopen("in.txt", "r", stdin);
	List L;
	int op1 = 1, op2 = 1,op3 = 1,op4 = 1;
	double a;
	int b, cases = 1,flag;
	while(scanf("%s", s) != EOF)
	{
        printf("Case %d:\n",cases++);
        InitList(L);
		op1 = op2 = op3 = op4 = 1;
		flag = 0;
		int len = strlen(s);
		for(int i = -10000;i <= 10000;i ++)
			m[i] = -1;
		int k = 0;
		for(int i = 0;i < len;i ++)
		{
            a = 0;
			b = 0;
			op1 = op2 = 1;
			if(s[0] == '-' && i == 0)
            {
                op4 = -1;
                i ++;
            }
            if(s[i+1] == '(')
            {
                Derivative(k, L);
                flag = 1;
            }
			if(s[i] == '=') break;
			if(s[i] == '(') continue;
			if(s[i] == ')')
			{

				i ++;
				op4 = 1;
				if(s[i] == '=')
                {
					 if(!flag)
                        Derivative(k, L);
                     break;
                }
				else
				{
                    flag = 1;
					Derivative(k, L);
					if(s[i] == '+')
						op3 = 1;
					else if(s[i] == '-')
						op3 = -1;

				}
			}
            if(s[i] == '-')
			{

				i ++;
				op1 = -1;
			}
			else if(s[i] == '+')
			{
				i ++;
				op1 = 1;
			}
			if(s[i] >= '0' && s[i] <= '9')
			{
				while(s[i] >= '0' && s[i] <= '9' && i < len)
				{
					a = a*10+(s[i]-'0');
					i ++;
				}
				if(s[i] == '.')
				{
					i ++;
					double x = 0.1;
					while(s[i] >= '0' && s[i] <= '9' && i < len)
					{
						a += x*(s[i]-'0');
						i ++;
						x *= 0.1;
					}
				}
				a = a*op1*op3*op4;
			}
			else if(s[i] == 'x')
			{
				a = op1*op3*op4;
			}
			if(s[i] == 'x')
			{
				i ++;
				if(s[i] == '^')
				{
					i ++;
					if(s[i] == '-')
					{
						op2 = -1;
						i ++;
					}
                    else if(s[i] == '+')
					{
						op2 = 1;
						i ++;
					}
					while(s[i] >= '0' && s[i] <= '9' && i < len)
					{
						b = b*10 + s[i] - '0';
						i ++;
					}
					b = b*op2;
					i --;
				}
				else
				{
					b = op2;
					i --;
				}
			}
			else
			{
				b = 0;
				i --;
			}
		    if(m[b] == -1)
			{
                L.elem[k].coef = a;
                L.elem[k].exp = b;
			    m[b] = k;
				k ++;
			}
			else
			{
				L.elem[m[b]].coef += a;
            }
        }
		sort(L.elem, L.elem+k, cmp);
		int flag = 0;
		int n = 1;
	    printf("%s", s);
		for(int i = 0;i < k;i ++)
		{
			if(fabs(L.elem[i].coef) < 1e-6)	continue;
			else
			{
				flag = 1;
				if(n != 1 && L.elem[i].coef > 0)
                    printf("+");
                if(L.elem[i].exp == 0)
                    printf("%g", L.elem[i].coef);
                else if(L.elem[i].coef != 1 && L.elem[i].exp != 0 && L.elem[i].coef != -1)
                {
                    if(L.elem[i].exp == 1)
                        printf("%gx",L.elem[i].coef);
                    else
                        printf("%gx^%d",L.elem[i].coef, L.elem[i].exp);
                }
                else if(L.elem[i].coef == 1)
                {
                    if(L.elem[i].exp == 1)
                        printf("x");
                    else
                        printf("x^%d",L.elem[i].exp);
                }
                else if(L.elem[i].coef == -1)
                {
                     if(L.elem[i].exp == 1)
                        printf("-x");
                    else
                        printf("-x^%d",L.elem[i].exp);
                }
				n ++;
			}
        }
		if(!flag) printf("0");
        printf("\n");
	}
	return 0;
}

链表实现： 


#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <string>
#include <cmath>
#include "AddPolyn.h"
#include "Derivative.h"
using namespace std;
#define maxlen 1000
int main()
{
    char s[maxlen];
    int casen = 1;
    freopen("in.txt", "r", stdin);
    freopen("out.txt","w",stdout);
    while(scanf("%s", s) != EOF)
    {
        LNode* L1;
        init(L1);
        LNode* L2;
        init(L2);
        Inputpolyn(s, L1, L2);               //提取多项式中的系数和指数
        printf("Case %d :\n",casen ++);
        Deriv(L1);                           //求第一项的导数
        AddPolyn(L1, L2);                    //多项式相加
        printf("%s", s);
        print(L1);
        printf("\n");
    }
    return 0;
}



//Derivative.h
#ifndef DERIVATIVE_H_INCLUDED
#define DERIVATIVE_H_INCLUDED
void Deriv(LNode* L1)
{
    LNode* p = L1->next;
    double coef;
    int exp, n = 1, flag = 0;
    while(p)
    {
        coef = p->coef;
        exp = p->exp;
        if(exp == 0)
        {
            coef = 0;
        }
        else
        {
            coef *= exp;
            exp --;
        }
        //Êä³öµ¼Êý~~~~~~~~~~~~~~~~~~~~~~
         if(fabs(coef) < 1e-6)
        {
            p = p->next;
            continue;
        }
        else
        {
            flag = 1;
            if(n != 1 && coef > 0)
                printf("+");
            if(exp == 0)
                printf("%g", coef);
            else if(coef!= 1 && exp != 0 && coef != -1)
            {
                if(exp == 1)
                    printf("%gx",coef);
                else
                    printf("%gx^%d",coef, exp);
            }
            else if(coef == 1)
            {
                if(exp == 1)
                    printf("x");
                else
                    printf("x^%d",exp);
            }
            else if(coef == -1)
            {
                if(exp == 1)
                    printf("-x");
                else
                    printf("-x^%d",exp);
            }
            n ++;
        }
        p = p->next;
    }
    if(!flag) printf("0");
    printf("\n");
}
#endif // DERIVATIVE_H_INCLUDED


//AddPolyn.h
#ifndef INPUTPOLYN_H_INCLUDED
#define INPUTPOLYN_H_INCLUDED
struct LNode
{
    double coef;   //系数
    int exp;       //指数
    LNode *next;
};
void init(LNode* &L)
{
    L = (LNode*) new LNode;
    L -> next = NULL;
}
int compare(int x, int y)
{
    if(x == y) return 0;
    if(x < y) return 1;
    return -1;
}
void Insert(double coef, int exp, LNode* &L)
{
    LNode* p = L->next;
    LNode* q = L;
    while(p != NULL )
    {
        LNode *s;
        int flag = compare(exp, p->exp);
        if(flag == -1)     //比当前指数大
        {
            q = p;
            p = p->next;
        }
        else if(flag == 1) //比当前指数小
        {
            s = (LNode* )new LNode;
            s->coef = coef;
            s->exp = exp;
            s->next = p;
            q->next = s;
            return;
        }
        else if(flag == 0) //与当前指数相等
        {
            p->coef += coef;
            return;
        }
    }
    LNode*s = (LNode*) new LNode;
    s->coef = coef;
    s->exp = exp;
    s->next = NULL;
    q->next = s;
    return;


}
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~读取多项式
void Inputpolyn(char s[], LNode* &L1, LNode* &L2)
{
    int op1 = 1,op2 = 1,op4 = 1,len,p;
    double a = 0;
    int b = 0;
    len = strlen(s);
    //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~读第一个多项式
    for(int i = 0; i < len; i ++)
    {
        a = 0;
        b = 0;
        op1 = op2 = 1;
        if(s[i] == '=')
            break;
        if(s[0] == '-' && i == 0)
        {
            op4 = -1;
            i ++;
        }
        if(s[i] == '(') continue;
        if(s[i] == ')')
        {
            p = i;
            break;
        }
        else if(s[i+1] == '(')
        {
            p = i-1;
            break;
        }
        if(s[i] == '-')
        {
            i ++;
            op1 = -1;
        }
        else if(s[i] == '+')
        {
            i ++;
            op1 = 1;
        }
        if(s[i] >= '0' && s[i] <= '9')
        {
            while(s[i] >= '0' && s[i] <= '9' && i < len)
            {
                a = a*10+(s[i]-'0');
                i ++;
            }
            if(s[i] == '.')
            {
                i ++;
                double x = 0.1;
                while(s[i] >= '0' && s[i] <= '9' && i < len)
                {
                    a += x*(s[i]-'0');
                    i ++;
                    x *= 0.1;
                }
            }
            a = a*op1*op4;
        }
        else if(s[i] == 'x')
        {
            a = op1*op4;
        }
        if(s[i] == 'x')
        {
            i ++;
            if(s[i] == '^')
            {
                i ++;
                if(s[i] == '-')
                {
                    op2 = -1;
                    i ++;
                }
                else if(s[i] == '+')
                {
                    op2 = 1;
                    i ++;
                }
                while(s[i] >= '0' && s[i] <= '9' && i < len)
                {
                    b = b*10 + s[i] - '0';
                    i ++;
                }
                b = b*op2;
                i --;
            }
            else
            {
                b = op2;
                i --;
            }
        }
        else
        {
            b = 0;
            i --;
        }
        //i --;
        //printf("%lf %d", a, b);
        Insert(a, b, L1);
    }
    //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~读第二个多项式
    op4 = 1;
    for(int i = p+1; i < len; i ++)
    {
        a = 0;
        b = 0;
        op1 = op2 = 1;
        if(s[i] == '-' && i == p+1)
        {
            op4 = -1;
            i ++;
        }
        else if(s[i] == '+' && i == p+1)
        {

            op4 = 1;
            i++;
        }
        if(s[i] == '=') break;
        if(s[i] == '(') continue;
        if(s[i] == ')')
        {
            i ++;
            if(s[i] == '=')
                break;
        }
        if(s[i] == '-')
        {
            i ++;
            op1 = -1;
        }
        else if(s[i] == '+')
        {
            i ++;
            op1 = 1;
        }
        if(s[i] >= '0' && s[i] <= '9')
        {
            while(s[i] >= '0' && s[i] <= '9' && i < len)
            {
                a = a*10+(s[i]-'0');
                i ++;
            }
            if(s[i] == '.')
            {
                i ++;
                double x = 0.1;
                while(s[i] >= '0' && s[i] <= '9' && i < len)
                {
                    a += x*(s[i]-'0');
                    i ++;
                    x *= 0.1;
                }
            }
            a = a*op1*op4;
        }
        else if(s[i] == 'x')
        {
            a = op1*op4;
        }
        if(s[i] == 'x')
        {
            i ++;
            if(s[i] == '^')
            {
                i ++;
                if(s[i] == '-')
                {
                    op2 = -1;
                    i ++;
                }
                else if(s[i] == '+')
                {
                    op2 = 1;
                    i ++;
                }
                while(s[i] >= '0' && s[i] <= '9' && i < len)
                {
                    b = b*10 + s[i] - '0';
                    i ++;
                }
                b = b*op2;
                i --;
            }
            else
            {
                b = op2;
                i --;
            }
        }
        else
        {
            b = 0;
            i --;
        }
        Insert(a, b, L2);
    }
}
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~两个多项式相加
void AddPolyn(LNode* &L1, LNode* &L2)
{
    LNode* p1 = L1->next, *p2 = L2->next, *r = L1, *q;
    //LNode* pre1 = L1,*pre2 = L2;
    while(p1 && p2)
    {
        int flag = compare(p1->exp, p2->exp);
        if(flag == 1)
        {
            r->next = p1;
            r = p1;
            //pre1= p1;
            p1 = p1->next;
        }
        else if(flag == -1)
        {
            r->next = p2;
            r = p2;
            //pre2 = p2;
            p2 = p2->next;
        }
        else if(flag == 0)
        {
            double sum = p1->coef + p2->coef;
            if(fabs(sum) < 1e-5)
            {
                if(L1->next == p1)
                    L1->next = p1->next;
                q = p1;
                p1 = p1->next;
                delete q;
            }
            else
            {
                p1->coef = sum;
                r->next = p1;
                r = p1;
                p1 = p1->next;
            }
            //if(pre2->next == p2)
            //pre2->next = p2->next;
            q = p2;
            p2 = p2->next;

            delete q;
        }
    }
    if(p1)
        r->next = p1;
    if(p2)
        r->next = p2;
    delete L2;
    L2 = q = p1 = p2 = r = NULL;
}
void print(LNode *L)
{
    int flag = 0,n = 1;
    LNode *p = L->next;
    while(p)
    {
        double coef = p->coef;
        int exp = p->exp;
        //cout << coef <<" "<<exp<<endl;
        if(fabs(coef) < 1e-6)
        {
            p = p->next;
            continue;
        }
        else
        {
            flag = 1;
            //if(n == 1) printf("(");
            if(n != 1 && coef > 0)
                printf("+");
            if(exp == 0)
                printf("%g", coef);
            else if(coef!= 1 && exp != 0 && coef != -1)
            {
                if(exp == 1)
                    printf("%gx",coef);
                else
                    printf("%gx^%d",coef, exp);
            }
            else if(coef == 1)
            {
                if(exp == 1)
                    printf("x");
                else
                    printf("x^%d",exp);
            }
            else if(coef == -1)
            {
                if(exp == 1)
                    printf("-x");
                else
                    printf("-x^%d",exp);
            }
            n ++;
        }
        p = p->next;
    }
    if(!flag) printf("0");
    //else printf(");");
    return;
}
#endif // INPUTPOLYN_H_INCLUDED

测试数据：

(2x+5x^8-3.1x^11)+(7-5x^8+11x^9)=
(6x^-3-x+4.4x^2-1.2x^9+1.2x^9)-(-6x^-3+5.4x^2-x^2+7.8x^15)=
(1+x+x^2+x^3+x^4+x^5)+(-x^3-x^4)=
(x+x^3)+(-x-x^3)=
(x+x^100)+(x^100+x^200)=
(x+x^2+x^3)+0=
(7-5x^8+11x^9)+(2x+5x^8-3.1x^11)=
-(-6x^-3+5.4x^2-x^2+7.8x^15)+(6x^-3-x+4.4x^2-1.2x^9+1.2x^9)=
(-x^3-x^4)+(1+x+x^2+x^3+x^4+x^5)=
(-x-x^3)+(x+x^3)=
(x+x^100)+(x^100+x^200)=
0+(x+x^2+x^3)=
(x+x)=
(1+x-x)+x=
(x-9+x^100)+(x-x^8)=
(-x+x)=
(23+10)=

输出结果（输出第一行为第一项的导数值）：

Case 1 :
2+40x^7-34.1x^10
(2x+5x^8-3.1x^11)+(7-5x^8+11x^9)=7+2x+11x^9-3.1x^11
Case 2 :
-18x^-4-1+8.8x
(6x^-3-x+4.4x^2-1.2x^9+1.2x^9)-(-6x^-3+5.4x^2-x^2+7.8x^15)=12x^-3-x-7.8x^15
Case 3 :
1+2x+3x^2+4x^3+5x^4
(1+x+x^2+x^3+x^4+x^5)+(-x^3-x^4)=1+x+x^2+x^5
Case 4 :
1+3x^2
(x+x^3)+(-x-x^3)=0
Case 5 :
1+100x^99
(x+x^100)+(x^100+x^200)=x+2x^100+x^200
Case 6 :
1+2x+3x^2
(x+x^2+x^3)+0=x+x^2+x^3
Case 7 :
-40x^7+99x^8
(7-5x^8+11x^9)+(2x+5x^8-3.1x^11)=7+2x+11x^9-3.1x^11
Case 8 :
-18x^-4-8.8x-117x^14
-(-6x^-3+5.4x^2-x^2+7.8x^15)+(6x^-3-x+4.4x^2-1.2x^9+1.2x^9)=12x^-3-x-7.8x^15
Case 9 :
-3x^2-4x^3
(-x^3-x^4)+(1+x+x^2+x^3+x^4+x^5)=1+x+x^2+x^5
Case 10 :
-1-3x^2
(-x-x^3)+(x+x^3)=0
Case 11 :
1+100x^99
(x+x^100)+(x^100+x^200)=x+2x^100+x^200
Case 12 :
0
0+(x+x^2+x^3)=x+x^2+x^3
Case 13 :
2
(x+x)=2x
Case 14 :
0
(1+x-x)+x=1+x
Case 15 :
1+100x^99
(x-9+x^100)+(x-x^8)=-9+2x-x^8+x^100
Case 16 :
0
(-x+x)=0
Case 17 :
0
(23+10)=33


墨温温
关注
  • 4
    点赞
  • 踩
  • 56
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
链表实现一元多项式相加
qq_51500472的博客
10-23 2482
C++链表实现一元多项式相加代码如下： （输入多项式按次数从高到低排列） #include <iostream> #include <stdio.h> using namespace std; int main() { struct node{ int coe; int order; struct node *link; };//定义节点类型，coe表示x前的系数，order表示x的次数 int coe,o
一元多项式相加用链表实现
11-09
题目说明： 编写一元多项式加法运算程序。要求用线性链表存储一元多项式（参照课本）。该程序有以下几个功能： 1. 多项式求和 输入：输入三个多项式，建立三个多项式链表Pa、Pb、Pc （提示：调用CreatePolyn(polynomial &P,int m)。 输出：显示三个输入多项式Pa、Pb、Pc、和多项式Pa+Pb、多项式Pa+Pb+Pc （提示：调用AddPolyn(polynomial &Pa, polynomial Pb), 调用PrintPolyn(polynomial P))。 0. 退出 输入： 根据所选功能的不同，输入格式要求如下所示（第一个数据是功能选择编号，参见测试用例）： 1 多项式A包含的项数，以指数递增的顺序输入多项式A各项的系数（整数）、指数（整数） 多项式B包含的项数，以指数递增的顺序输入多项式B各项的系数（整数）、指数（整数） 多项式C包含的项数，以指数递增的顺序输入多项式C各项的系数（整数）、指数（整数） 0 －－－操作终止，退出。 输出： 对应一组输入，输出一次操作的结果（参见测试用例）。 1 多项式输出格式：以指数递增的顺序输出: ,,,参见测试用例。零多项式的输出格式为 0 无输出
C++ 链表实现两个一元多项式相加
09-15
c++，算法链表实现一元多项式相加，通过链表实现，非常好的一个程序
顺序表应用之两个一元多项式求和
silence2015的专栏
02-18 7734
#include <stdio.h> #include <malloc.h> typedef struct node{ int coef;//系数 int exp;//指数 struct node *next; }NODE;NODE *creatPoly(){ int coef; int exp; NODE *head,*tail,*s;//链表头结点
数据结构实验之一元多项式相加
Chen_dSir的博客
11-26 9046
【实验内容】结合书上第41页的例子，采用链式存储结构，将两个线性链表表示的一元多项式相加，并输出。此一元多项式遵循多项式相加运算规则：对于两个一元多项式中存在指数相同的项时，其对应系数相加。合并后系数和为零时，删除“和多项式”中此项；合并后系数和不为零时，则构成“和多项式”中的一项。对于两个一元多项式中存在的指数不相同的项，则分别复抄到“和多项式”中去，原多项式保持不变。
C语言数据结构实现——一元多项式的基本运算
mcr1379673758的博客
03-17 1万+
该算法使用C语言的数据结构知识实现一元多项式的基本运算（加法、减法、乘法）。
运用顺序表实现多项式相加
分享自己的经验、IT技术，愿在博客中遇见更好的自己
09-29 1174
本题要求输入两个一元多项式，然后输出它们的和（相加后得到的一元多项式）输入格式: 输入一个整数n（表示输入组数），然后依次输入每一组数据：输入一个整数A（表示多项式的项数，小于100），然后输入A对整数，每一对整数表示对应项的指数和系数。输出格式:对每一组输入，在一行中输出得到的一元多项式。输入样例:在这里给出一组输入。例如：2 5 0 2 1 4 5 7 7 10 8 19 4 0 3 2 6 4 19 5 -9 3 0 3 4 7 8 2 3 0 -3 5 9 7 21
cpp链表实现一元多项式表示，相加，相乘
最新发布
06-18
两个多项式相加需要遍历两个链表，并将具有相同指数的项合并。如果一个多项式中没有某个指数的项，那么另一个多项式的相应项可以直接保留： ```cpp Polynomial Polynomial::add(const Polynomial& other) const { ...
一元多项式的表示与相加，用链表解决
10-11
多项式相加涉及两个链表的合并。首先，我们遍历两个链表，如果一个链表为空，则返回另一个链表作为结果。否则，我们将两个链表的最高次项相加，然后继续遍历并处理下一项。如果两个多项式的当前项相同，我们只需将...
c语言链表实现两个一元递增多项式的相加.zip
12-31
本项目"c语言链表实现两个一元递增多项式的相加"就是基于这一思想，通过链表来存储一元多项式的每一项，并实现两个多项式的相加。 首先，我们需要定义一个结构体来表示多项式的项。这个结构体通常包含两个字段：...
利用线性表实现一个一元多项式
12-07
可以使用链表实现，也可以使用顺序表实现 具体要求如下： 能够实现一元多项式的输入和输出 能够进行一元多项式相加 能够进行一元多项式相减 能够计算一元多项式在x处的值 能够计算一元多项式的导数（选作） ...
C语言一元多项式相加（链表）
热门推荐
m0_51415606的博客
10-30 2万+
今天写一个关于一元多项式相加的程序，就当是在练习运用一下链表的知识。首先，我们先来分析一波，一元多项式相加，首先要用链表创建两个或多个多项式，每个节点里的数据有两个，系数和指数；其次，如果要实现乱幂输入，那么还需要一个排序函数；然后就是多项式相加求和的部分，当指数相等时其系数相加，如果不相等那么就比较大小，依次存入新的链表；最后是输出函数，这个部分也分了很多类型，比如：两式相加为常数（2，4，6）、0、系数为1不显示系数（x，x^4）、指数为1不显示指数（x，2x）等等。 先来定义结构体变量，和单链表的定义
用链式线性表实现两个一元多项式相加
认真你就输了
03-26 5019
#include #include #include using namespace std; typedef struct PolyNode { int coef; int exp; PolyNode *next; }node; node * CreatPoly(){ PolyNode *h,*tail,*s; int coef,exp; h=( Pol
数据结构之线性结构-链表的应用（求两个一元多项式之和）
Leonard's Blog
02-22 4090
输入格式： 按照幂从大到小次序输入各结点的系数和幂 各结点的幂互不相同 测试值 多项式1：3X^3+2X^2+(-5)X+6 多项式2：-2X^3+(-2)X^2+5X+4 算法实现： 头文件： 结构体构造结点类型： 创建多项式链表： 将两个多项式相加： 输出多项式： 主函数： ...
【C 数据结构】 用单链表存储一元多项式，并实现两个多项式相加运算。
weixin_66397563的博客
10-13 5257
1 定义链式存储的数据结构、2 完成多项式的初始化，即给多项式赋初值、3 完成多项式的输出、4 实现多项式的相加及结果输出。 ​
数据结构——算法总结：一元多项式的表示与相加
weixin_73165588的博客
10-01 2030
*---------------头文件的定义---------------*///int定义为Status{ //项的表示,多项式的项作为LinkList的数据元素int coef;// 系数int expn;// 指数//结构体类型名为term，又重新定义结构体类型名为ElemTypetypedef struct LNode //结点类型//结点名为LNode，结点类型名为Link//又重新定义结点类型名为Positiontypedef struct //链表类型。
C语言实现一元多项式相加
qq_60511652的博客
01-18 3877
C语言，链表实现一元多项式相加
顺序表实现多项式相加
qq_43599143的博客
10-30 7545
数据结构——顺序表 #include <stdio.h> #include <stdlib.h> /** =====================存储结构定义 开始======================= */ #define MAX_SIZE 128 /*顺序表中元素的类型，描述多项式中每一项的系数和指数*/ typedef struct _Elem { in...
数据结构（C语言）-案例分析（顺序表实现多项式运算）
czh2637750821的博客
01-14 1847
顺序表实现多项式运算 //多项式基本运算 #include"stdio.h" #include"stdlib.h" #define MAX 100 typedef int Data; typedef struct{ Data data[MAX]; int Length; }SeqList; SeqList A; SeqList B; SeqList C; void InitList(SeqList *A,SeqList *B,SeqList *C){ A->Length=0; B->
构造两个按指数递增的有序链表，实现两个一元多项式相加
03-16
好的，以下是按指数递增构造有序链表并实现一元多项式相加的方法： 假设有两个一元多项式A和B，它们分别表示为： A(x) = a0 + a1x + a2x^2 + ... + anx^n B(x) = b0 + b1x + b2x^2 + ... + bmx^m 我们可以将它们的每一项系数与指数用一个结构体来表示： struct PolyNode { int coef; // 系数 int expn; // 指数 PolyNode *next; }; 接下来，我们可以按照指数递增的顺序，依次将A和B中的每一项插入到两个单独的链表中： PolyNode *CreatePoly(int n) { PolyNode *head = new PolyNode; // 创建头节点 head->next = NULL; PolyNode *p = head; // p指向当前节点 for (int i = 0; i < n; i++) { PolyNode *new_node = new PolyNode; new_node->next = NULL; cin >> new_node->coef >> new_node->expn; while (p->next != NULL && p->next->expn < new_node->expn) { p = p->next; // 找到第一个指数大于等于当前项的节点 } new_node->next = p->next; p->next = new_node; // 将当前项插入到链表中 p = head; // p重新指向头节点 } return head; } PolyNode *A = CreatePoly(n); PolyNode *B = CreatePoly(m); 接下来，我们可以定义一个新的链表C来表示A和B相加后的结果，同样按照指数递增的顺序将每一项插入到链表C中： PolyNode *AddPoly(PolyNode *A, PolyNode *B) { PolyNode *C = new PolyNode; // 创建头节点 C->next = NULL; PolyNode *p = A->next, *q = B->next, *r = C; // p和q分别指向A和B的当前节点，r指向C的当前节点 while (p != NULL && q != NULL) { if (p->expn < q->expn) { PolyNode *new_node = new PolyNode; new_node->coef = p->coef; new_node->expn = p->expn; new_node->next = NULL; r->next = new_node; r = new_node; // 将A中的当前项插入到C中 p = p->next; // p指向下一个节点 } else if (p->expn > q->expn) { PolyNode *new_node = new PolyNode; new_node->coef = q->coef; new_node->expn = q->expn; new_node->next = NULL; r->next = new_node; r = new_node; // 将B中的当前项插入到C中 q = q->next; // q指向下一个节点 } else { // 指数相同 int sum = p->coef + q->coef; if (sum != 0) { // 只有当系数之和不为0时，才需要插入新的节点 PolyNode *new_node = new PolyNode; new_node->coef = sum; new_node->expn = p->expn; new_node->next = NULL; r->next = new_node; r = new_node; // 将A和B中当前项的系数相加后插入到C中 } p = p->next; // p和q都指向下一个节点 q = q->next; } } while (p != NULL) { // 将A中剩余的项插入到C中 PolyNode *new_node = new PolyNode; new_node->coef = p->coef; new_node->expn = p->expn; new_node->next = NULL; r->next = new_node; r = new_node; p = p->next; } while (q != NULL) { // 将B中剩余的项插入到C中 PolyNode *new_node = new PolyNode; new_node->coef = q->coef; new_node->expn = q->expn; new_node->next = NULL; r->next = new_node; r = new_node; q = q->next; } return C; } PolyNode *C = AddPoly(A, B); 这样，我们就实现了按指数递增构造有序链表并实现一元多项式相加的功能。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值