精华内容
下载资源
问答
  • 两个多项式相加算法(链表实现)

    千次阅读 2020-11-28 19:17:43
    //多项式相加: #include <iostream> using namespace std; class Node {//项的定义 public: int a; int b; Node* next; Node(int aa, int bb) { a = aa; b = bb; next = NULL;; } }; class ...

    来源:数据结构期中考试补充题

    注:该代码测试数据较少,吃过晚饭有时间再测试下改改bug QAQ
    //多项式相加:
    #include <iostream>
    using namespace std;
    
    class Node {//项的定义
    	
    public:
    	int a;
    	int b;
    	Node* next;
    	Node(int aa, int bb) {
    		a = aa;
    		b = bb;
    		next = NULL;;
    	}
    };
    class List{
    public:
    	List() {
    		Creat();
    	}
    	Node* head;
    	void Creat();
    };
    void List::Creat() {
    	int num1, num2;
    	cout << "请输入该链表元素个数:" << endl;
    	int num;
    	cin >> num;
    	cout << "请输入组合(空格分隔即可)" << endl;
    	head = new Node(1, 1);
    	Node* p = head;
    	while (num--) { //创建一个单链表;
    		cin >> num1 >> num2;
    		Node* s = new Node(num1, num2);
    		p->next = s; 
    		p = s;
    	}
    	p->next = NULL;
    }
    Node* Add(List &A,List &B) {
    	Node* pc = A.head;
    	Node* pa = A.head->next;
    	Node* pb = B.head->next;
    	while (pa && pb) {
    		int num1 = pa->b;
    		int num2 = pb->b;
    		if (num1 == num2) {
    			//如果指数相同,加和为0
    			if (pa->a + pb->a == 0) {
    				Node* p1 = pa;
    				pa = pa->next;
    				Node* p2 = pb;
    				pb = pb->next;
    				delete p1, p2;
    			}
    			//指数相同,加和不为0
    			else {
    				pa->a = pa->a + pb->a;
    				pc->next = pa;
    				pc = pa;
    				Node* p = pb;
    				pb = pb->next;
    				delete(p);
    			}
    		}
    		//如果不相同,将指数小的接入新链表:
    		else {
    			if (num1 < num2) {
    				pc->next = pa;
    				pc = pa;
    				pa = pa->next;
    			}
    			else {
    				pc->next = pb;
    				pc = pb;
    				pb = pb->next;
    			}
    		}
    	}
    	if (pa == NULL) {
    		pc->next = pb;
    	}
    	else pc->next = pa;
    	return A.head;
    }
    //表的定义:
    int main() {
    	cout << "创建链表A:" << endl;
    	List A;
    	cout << "创建链表B:" << endl;
    	List B;
    	Node* c=Add(A, B);
    	Node* C = c->next;
    	while (C != NULL) {
    		cout << C->a << "*" << "X" << C->b << ' ';
    		C = C->next;
    	}
    	return 0;
    }
    
    
    

    欢迎各位的讨论交流和批评指正:)

    展开全文
  • 南昌航空大学实验报告 课程名称 数据结构 ...单链表结构实现两个多项式相加的运算并就地逆置相加后的多项式链式 一 需求分析 1. 用户可以根据自己的需求分别输入两个一元多项式 并且能够实现输入的一元多项式的 显示
  • 给定两个一元多项式,实现两个一元多项式相加算法。提示:用一条单链表表示一个一元多项式,每个节点包含三个域:指数域、系数域和后继结点链。 可直接运行 #include <stdio.h> #include <stdlib.h> #...

    给定两个一元多项式,实现两个一元多项式的相加算法。提示:用一条单链表表示一个一元多项式,每个节点包含三个域:指数域、系数域和后继结点链。

    可直接运行

    #include <stdio.h>
    #include <stdlib.h>
    #include <malloc.h>
    struct Node;
    typedef struct Node *PNode;
    struct Node
    {
        int zhishu;
        int xishu;
        PNode next;
    };
    typedef struct Node *LinkList;
    LinkList createNullList_link(void)//创建空链表
    {
        LinkList llist = (LinkList)malloc(sizeof(struct Node));
        if(llist != NULL) llist -> next = NULL;
        else
        {
            printf("out of space!\n");
        }
        return llist;
    }
    PNode locate_link(LinkList llist,int zhishu)//求某元素的存储位置
    {
        PNode p;
        if(llist == NULL) return NULL;
        p = llist->next;
        while(p != NULL && p->zhishu!=zhishu)p=p->next;
        return p;
    }
    int insertPost_link(LinkList llist,PNode p,int zhishu,int xishu)//在p节点后添加新节点
    {
        PNode q = (PNode)malloc(sizeof(struct Node));
        if(q==NULL) {
            printf("out of space.");
            return 0;
        }
        else
        {
            q->zhishu=zhishu; 
            q->xishu=xishu;
            q->next=p->next;
            p->next=q;
            return 1;
        }
        
    }
    int main() 
    {
        LinkList a1 = createNullList_link();
        insertPost_link(a1,a1,1,4);
        PNode p1 = a1->next;
        insertPost_link(a1, p1, 0, 5);
        LinkList a2 = createNullList_link();
        insertPost_link(a2, a2, 1, 6);
        PNode p2 = a2->next;
        insertPost_link(a2, p2, 0, 3);
        //以上设置好了两个一元多项式
        PNode p11 = locate_link(a1,1);
        PNode p21 = locate_link(a2, 1);
        PNode p10 = locate_link(a1, 0);
        PNode p20 = locate_link(a2, 0);
        int xishu1 = p11->xishu + p21->xishu;
        int xishu0 = p10->xishu+p20->xishu;
        printf("the sum is %d x + %d",xishu1,xishu0);
        return 0;
    }
    
    展开全文
  • 这是一个C语言版的两个一元多项式相加的程序,希望对大家有所帮助!
  • 多项式相加算法C++

    2011-08-05 11:18:51
    两个多项式相加,可以自己修改下,写成循环,多个多项式相加
  • 双链表&链表合并&多项式相加算法

    千次阅读 2014-08-11 20:10:37
    3)多项式相加:两个链表合并,系数为0的项删掉 linklist *add(linklist *la,linklist *lb) {  linklist *lc,*pc,*pa,*pb,*flag;  lc=(linklist *)malloc(sizeof(linklist));  pc=(linklist *)malloc...

     //单链表的合并

    //链表合并
    //两个链表必须是有序的
    #define Maxsize 5
    typedef  int elemtype;
    typedef struct linklist

      elemtype data;
       struct linklist *next;
    }Linklist;


     //建立链表1
    Linklist *CreateList1 ()

    int i,data ;
    Linklist *head, *p, *q;
    head=p=(Linklist  *)malloc(sizeof(Linklist)); 
    p->next=NULL;        //创建单链表的表头结点head  


        for(i=0;i<Maxsize;i++)
    {    
            data =2*i;
    q= (Linklist  *)malloc(sizeof(Linklist)); 
    q->data=data;    
    q->next=p->next; 
    p->next=q;
    p=q;
        }
        return (head);   
    }


    //建立链表2
    Linklist *CreateList2 ()

    int i,data ;
    Linklist *head, *p, *q;
    head=p=(Linklist  *)malloc(sizeof(Linklist)); 
    p->next=NULL;        //创建单链表的表头结点head  


        for(i=0;i<Maxsize;i++)
    {    
            data =2*i+1;  //减10,两个链表不等
    q= (Linklist  *)malloc(sizeof(Linklist)); 
    q->data=data;    
    q->next=p->next; 
    p->next=q;
    p=q; 

    }
        return (head);   
    }


    int main()
    {
       linklist *La=CreateList1();
       linklist *Lb=CreateList2();


       linklist *Lc,*L1,*L2,*Lp;
       Lc=(Linklist *)malloc(sizeof(Linklist));
       Lc->next=NULL;
       Lc->next=La->data < Lb->data ? La:Lb;
       L1=La;
       L2=Lb;
       Lp=Lc;
       while(L1->next!= NULL && L2->next!=NULL)
       {
      if(L1->data < L2->data )
      {  
      Lp->next=L1;
      L1=L1->next;
      }
      if(L1->data > L2->data )
      {  
      Lp->next=L2;
      L2=L2->next;
      }
           if(L1->data == L2->data )
      {  
      Lp->next=L1;
      L1=L1->next;
      L2=L2->next;
      }
       }
       if(L1->next= NULL)
      Lp->next=L2;
       else
      Lp->next=L1;


       while(1);
       return 0;
    }

    //循环链表的条件: p->next=head;
                    
     //双向链表
    ADT:
       typedef struct dullinklist
    {
      elemtype data;
      struct dullinklist *prior,*next;
    }                      
    ADP:
    //添加一个结点:假设在p,q中间添加一个结点add:
    dullinklist *add;
    add=(dullinklist *)malloc(sizeof(dullinklist));
    add.data=data;
    p->next=add;
    add->next=q;
    q->prior=add
    add->next=p;
    //删除一个结点:


    p->prior->next=p->next;
    p->next->prior=p->prior;
    free(p);


    //线性表和链表的应用——多项式的加减法
    1)线性表表示法:
    typedef struct linearlist
    {
      elemtypefloat factor; //系数
      elemtypeint series;   //级数
    }
    多项式的每一项都由级数和系数唯一确定,但是对于某些系数为0的项,会占用内存浪费资源
    因此使用链表


    2)链表表示法
    typedef struct linklist
    {
      elemtypefloat factor; //系数
      elemtypeint series;   //级数
      struct linearlist *next;
    }
    3)多项式相加:两个链表合并,系数为0的项删掉
    linklist *add(linklist *la,linklist *lb)
    {
      linklist *lc,*pc,*pa,*pb,*flag;
      lc=(linklist *)malloc(sizeof(linklist));
      pc=(linklist *)malloc(sizeof(linklist));
      pa=(linklist *)malloc(sizeof(linklist));
      pb=(linklist *)malloc(sizeof(linklist));
      
      lc=pc;
      lc->next=pa;
      pa=la;
      pb=lb;
      while(pa->next!=NULL && pb->next!=NULL)
     {
       if(pa->series < pb=series)
       {
        pc-next=pa; 
        pc=pa;
        pa=pa-next;  
       }
        if(pa->series > pb->series)
       {
        pc-next=pb;
        pc=pb;
        pb=pb-next;  
       }
       if(pa->series = pb->series)
       {
          elemtype x=pa->factor+pb->factor;
          if(x<=1e-6)
            {
             flag=pa;
             pa=pa->next;
             pb=pb->next;
             free(pa);
             free(pb); 
             }
           else
            {
              pc->factor=x;
              pc-next=pa;
              pc=pa;
              pa=pa-next;  
              flag=pb;
              pb=pb->next;
              free(pb);
            }
        }
      }
     if(pa==NULL)  
        pc->next=pb ;
     else  
        pc->next=pa ;
     return (Lc) ;  
    }
    展开全文
  • 单链表实现多项式相加

    千次阅读 多人点赞 2018-12-03 23:39:25
    单链表实现两个多项式相加 本程序使用链表实现了两个多项式的相加。 多项式的相加主要是考虑相加项的指数是否相同,如果相同则系数相加,指数不变。 本程序当中,实现该过程的思想为,在录入一个多项式所有项的...

    单链表实现两个多项式相加

    本程序使用链表实现了两个多项式的相加。
    多项式的相加主要是考虑相加项的指数是否相同,如果相同则系数相加,指数不变。
    本程序当中,实现该过程的思想为,在录入一个多项式所有项的系数和指数以后,使用链表思想构造一条单链表,记作链表A,结 点存储项的系数和指数。依照此法,构建第二条多项式链表,记作链表B。这样准备工作就完成了,下面开始实现多项式的相加,第一种方法(本程序采用第二种方法),构造第三条链表(记作链表C)用于存储相加之后的多项式,开始从多项式A的第一项开始,依次对比自身项以及多项式B的项,找到与其指数相同的项,将他们的系数相加,再将得到的结果存入新产生结点存系数的数据域,同时复制指数到新产生结点存指数的数据域(第一个结点作为链表C的头结点),对链表A的第一项对比完成以后,再对比链表A的第二项,查找链表A与链表B有没有与其指数相同的项,将相同项的系数相加,复制指数,再次存到新产生的新结点当中。再对比链表A的第三项,第四项…第n项。对比链表A完成以后,是否需要对比链表B?答案是肯定的,因为链表B里也可能存在指数相同的项,但是在对比链表B的项的时候是不用再对比链表A的,因为链表A对比完成以后,链表B当中剩下的项的指数应该是与链表A中所有项的指数都不相同,这些项当中可能存在指数相同的项,这些项是需要处理的。但是说到这里,有一个问题出现了,已经对比过的项该怎么办,不能再次进行对比后指数相同之后系数相加呀,所以我们需要去除对比之后的项,只有这样才能做到不重复相加,当链表A和链表B按照上述的方法进行对比以后,所有指数相同的项都会进行系数相加,连同指数一起存到链表C当中,剩下的就是指数都不相同的项,对于这些项,我们只需要复制到链表C当中即可。但是像这样对两条链表进行操作,多少有点麻烦,如果我们一开始就将两条链表连成一条链表呢,这就是我们下面要说的第二种办法,当链表A和链表B产生以后,我们立即将两条链表连成一条,然后再去进行所有项的指数进行对比,相同指数的项进行系数相加,直接复制到这些项的第一项,然后删掉其他项,这样做就避免了链表C的建立,直接在合成链表上进行操作,对比完成以后,该合成链表就是链表A和链表B相加得到的链表C,同时,在这条链表上可能存在系数为零的项,这些项也是有必要去除的,那么就再进行一次链表C的遍历,将所有系数为零的项删掉就可以了,这样就全部叙述完毕了,实现了链表的相加。

    程序执行效果图:
    在这里插入图片描述

    #include <stdio.h>
    #include <malloc.h>     
    #define NUM 2
    #define MAX 100		        
    
    typedef struct pnode   
    { 
        int coef;        
        int exp;           
        struct pnode *next;
    }PolyNode;
    
    PolyNode *aHead,*bHead,*cHead;
    void DispPoly(PolyNode *head)  
    {
    	PolyNode *p;
    	p=head;
    	while (p != NULL)
    	{ 
    		if (p->coef > 0 && p != head)
    		{
    			printf("+");
    		}		
    		if (p->exp == 0)
    		{
    			printf("%d",p->coef);
    		}
    			else if (p->exp==1)
    		{
    			printf("%dx",p->coef);
    		}
    		else
    		{
    			printf("%dx^%d",p->coef,p->exp);
    		}
    		p=p->next;
    	}
    	printf("\n");
    }
    
    void DestroyList(PolyNode *&head)  
    {
    	PolyNode *p,*s;
    	p=head;
    	s=head->next;
    	while (s != NULL)
    	{
    		free(p);
    		p=s;
    		s=p->next;
    	}
    	free(p);
    }
    
    
    void createList(PolyNode *&head,int arr[][NUM],int xs) 
    {
    	PolyNode *p,*s;
    	for (int i=0; i < xs; i++)
    	{
    		p = (PolyNode *)malloc(sizeof(PolyNode));
    		p->coef = arr[i][0];
    		p->exp  = arr[i][1];	
    		if(head == NULL)
    		{
    			head = p;
    		}
    		else
    		{
    			s->next = p;
    		}		
    		s = p;
    	}
    	s->next = NULL;
    }
    
    void Add(PolyNode *&ahead,PolyNode *&bhead) 
    {
    	PolyNode *p,*q,*s;
    	q = aHead;
    	while(q != NULL)
    	{
    		p = q;
    		q = q->next;
    	}
    	p->next = bHead;
    	printf("\n\n\t\t连接:");
    	DispPoly(aHead);
    
    	q = aHead;
    	while(q != NULL)
    	{
    		p = q;
    		s = q;
    		p = p->next;		
    		while(p != NULL)
    		{				
    			if(p->exp == q->exp)
    			{
    				q->coef = q->coef+p->coef;				
    				s->next = p->next;
    				free(p);
    				p  = s;
    			}
    			s = p;			
    			p = p->next;
    		}
    		q=q->next;				
    	}
    	printf("\n\t\t相加处理:");
    	DispPoly(aHead);
    
    	q = aHead;//q指针回到开始
    	p = aHead;//p指针回到开始
    	//s = aHead;
    	q = p;
    	while(q != NULL)
    	{
    		if(q->coef == 0 )
    		{
    			if(q == aHead)
    			{				
    				aHead = q ->next;
    				q = aHead;//q指针回到开始
    				p = aHead;//p指针回到开始				
    			}
    			else
    			{
    				p->next = q->next;
    				free(p);
    				p = q;		
    			}
    		}
    		p = q;
    		q = q->next;
    	}
    	printf("\n\t\t去除零项:");
    	DispPoly(aHead);
    }
    
    
    int main()
    {
    	int aNum = 0;
    	int bNum = 0;
    	int A[MAX][NUM] = {0};
    	int B[MAX][NUM] = {0};
    
    	while(1)
    	{
    		printf("\n\t\t请输入多项式A的项数:");
    		scanf("%d",&aNum);
    		if(aNum != 0)
    		{
    			break;
    		}
    		else
    		{
    			printf("\n\t\t不允许输入 0 项!请重新输入!\n");
    		}
    	}
    
    	for(int i = 0; i < aNum; i++)
    	{
    		printf("\n\t\t第%2d项  系数:",i+1);
    		scanf("%d",&A[i][0]);
    		printf("\t\t\t指数:");
    		scanf("%d",&A[i][1]);
    	}
    
    	while(1)
    	{
    		printf("\n\t\t请输入多项式B的项数:");
    		scanf("%d",&bNum);
    		if(bNum != 0)
    		{
    			break;
    		}
    		else
    		{
    			printf("\n\t\t不允许输入 0 项!请重新输入!\n");
    		}
    	}
    
    	for(int j = 0; j < bNum; j++)
    	{
    		printf("\n\t\t第%2d项  系数:",j+1);
    		scanf("%d",&B[j][0]);
    		printf("\t\t\t指数:",j+1);
    		scanf("%d",&B[j][1]);
    	}
    
    	createList(aHead,A,aNum); 
    	printf("\n\t\t原A多项式:");
    	DispPoly(aHead);
    
    	createList(bHead,B,bNum); 
    	printf("\n\t\t原B多项式:");
    	DispPoly(bHead);
    
    	printf("\n\t\t相加得到的C多项式");
    	Add(aHead,bHead);
    	printf("\n\t\t");
    	DestroyList(aHead);
        	return 0;
    }
    

    如有错误,欢迎指正!_

    展开全文
  • 两个多项式相加

    2020-04-22 12:25:54
    两个多项式相加 每组有两行,每行由若干空格隔开的整数构成,以回车标志结束。 每行第一个数表示本行有几项,每一项由两个整数表示,第1个整数表示系数,第2个整数表示次数。 如: 第一个多项式:3x^5-2x+4;则在...
  • System.out.println("一元多项式的32313133353236313431303231363533e78988e69d8331333365646233相加过程:"); list1.listAll(); System.out.println(" + "); list2.listAll(); System.out.println(" = "); list3....
  • 一元多项式相加可实现代码(c语言) 《数据结构》(C语言版)书上是伪代码,经过不断修改调试,写下可实现的C语言源代码。 创建文件,分为两部分:头文件(Poly.h)和源文件(Poly.c) 一、实验目的 1、了解一元多项式...
  • 数据结构与算法-- 一元多项式相加

    千次阅读 2020-05-15 22:36:39
    //存放多项式某项的结点结构 struct node { int exp ; // 表示指数 int coef ; //表示系数 struct node *next; //指向下一个结点的指针 }; typedef struct node * PNODE ; /* 函数功能:生成多项式 函数名:...
  • 一元多项式相加

    2019-12-19 01:12:58
    1.采用顺序存储结构来存系数,对应单元的内容相加即可。 但在通常的应用中,多项式的指数有时可能会变化很高并且变化很大,如下图 用一长度为20001的线性表来表示,表中仅有3个非零元素,浪费空间。所以我们可以...
  • 多项式相加算法与结合多项式相加算法与结合多项式相加算法与结合多项式相加算法与结合
  • 根据所学的数据结构中线性结构(线性表) 的逻辑特性和物理特性及相关算法, 应用于求解一个具体的实际问题----------两个多项式相加
  • 完成两个多项式相加操作:已知有两个多项式P(x),Q(x),设计算法实现P(x)+Q(x)运算。而且对加法运算不重新开辟存储空间。要求用链式存储结构。 例如:P(x)=5x^3+2x+1,Q(x)=3x^3+x^2-2x-3,其计算输出结果为:8x^...
  • 链表实现多项式相加

    千次阅读 2018-01-29 20:15:43
    使用链表实现多项式相加,最终输出相加多项式。默认链表的指数为递增。输入时依次输入系数和指数,以0 0 作为结束标志。 比如: 多项式A:1+2*x-4*x^4 多项式B:2-2*x+5^x^4 输入: 0 1 2 1 -4 4 0 0 ...
  • 一元多项式相加算法和C++实现

    万次阅读 多人点赞 2015-08-13 15:53:08
    利用顺序表的链式存储实现一元多项式的加法
  • C++__一元多项式相加

    千次阅读 2018-09-28 16:27:29
    一元多项式每一项由系数Pi及x的指数i组成。若多项式按照升幂排列,则它由n+1个系数唯一确定,因此可以用一个线性表表示,其指数i隐藏在系数Pi的序号内。分别两个多项式A(x)、B(x)系数、指数所构成的表。输出为两...
  • 链表(篇5)用链表实现多项式相加

    千次阅读 2017-03-18 10:42:31
    使用链接实现两个多项式相加例:输入: 第一数目= 5x ^ 2 + 4x ^ 1 + 2x ^ 0 第二数= 5x ^ 1 + 5x ^ 0 输出: 5x ^ 2 + 9x ^ 1 + 7x ^ 0 输入: 第一数量= 5x ^ 3 + 4x ^ 2 + 2x ^ 0 第二数= 5x ^ 1 + 5x ^ 0 ...
  • 网上搜了一下大家的算法,发现以我的脑袋瓜子好像看不太懂。。。于是自己尝试着搞了一下,发现其实并不难嘻嘻嘻 #include<stdio.h> #include <stdlib.h> typedef int ElemType; typedef struct LNode ...
  • 按照数据结构的课本,本节知识将介绍多项式的一些曹
  • printf("两个多项式相加后的结果为:\n"); AddPolyn(pa,pb,pc); PrintPolyn(pc,n+m); return 0; } void PrintPolyn(Polylist L,int n) { Polylist p; int i=0; p=L->next; while(p && i) { i++; printf...
  • 为了计算多个一元多项式相加,参照书上P40的式子相加,需要建立在有序链表的基础上,跟merge的算法类似。链表的基本操作就不表述了。书P39-P43 二、需要用到的数据结构 1、单链表 //=============单链表=========...
  • C语言一元多项式相加(链表)

    千次阅读 多人点赞 2020-10-30 21:10:52
    今天写一个关于一元多项式相加的程序,就当是在练习运用一下链表的知识。首先,我们先来分析一波,一元多项式相加,首先要用链表创建两个或多个多项式,每个节点里的数据有两个,系数和指数;其次,如果要实现乱幂...
  • 多项式求和算法

    千次阅读 2015-07-13 11:24:48
    作者:whj95引言该算法用于解决形如S(x) = a0_0+a1_1x+a2_2x2^2+a3_3x3^3+…+ai_ixi^i+…+an−1_{n-1}xn−1^{n-1}+an_nxn^n的多项式的和。算法一:暴力破解 根据多项式的直观表示方法运用累加“+=”及幂函数“pow(x...
  • 为了便于计算,一元多项式一般用链表存储,并设置两个域,存储系数和指数。 typedef struct node{ int exp; //指数 float coef //系数 struct node next; }polynomial; void AddPoly(ploynomial &p,...
  • } } //两个一元多项式相加,返回新的一元多项式 public static LinkList mergeLinkList(LinkList list1, LinkList list2){ int i = 0; Item item = new Item(); Node curr1, curr2; LinkList list3 = new LinkList...

空空如也

空空如也

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

多项式相加算法