精华内容
下载资源
问答
  • 2020-11-01 01:13:51

    先科普一下线性表的相关知识。线性表,即由n个性质相同的数据元素组成的有序序列。线性表是最基础的线性结构,也是最基本的数据结构形式。因此学好线性表,也是学习其余数据结构的基础。

    而线性表分为两类:顺序表和链表。

    顺序表的最大特点,既存储该表数据元素的存储单元是连续的(话说这为什么算“顺序”啊……)。而链表则与之相反,是一种靠指针链接的,用任意存储单元存储数据元素的表,指针,就是该类表的“链”。而两表当中,链表的使用居多(至少凭我目前短浅的阅历是没怎么用过顺序表的)。

    所以,相较于顺序表而言,链表的应用居多,这里就以多项式加法为例说明。

    首先给出多项式加法的链表结构体:

    
    
    typedef int DataType;
    
     
    
    struct Node
    
    {
    
           DataType
    num;
    
           DataType
    modulus;
    
           struct
    Node* next;
    
    } ;
    
     
    
    typedef struct Node *PNode;
    
    typedef struct Node *LinkList;
    
    

    需要注意,三个typedef的作用:第一个typedef是为了可以更轻松的更改链表的存储元素结构,下面程序凡是涉及到链表存储元素时,都用其后面的DataType代替,这样一来,当之后需要更改链表存储元素结构时,可以直接从最上方的typedey入手,省时省力(当然输出函数里的还是需要注意的就是啦)。下方的两个typedef,一是为了简化定义变量的繁琐的关键字,二是便利其他的程序员阅读该程序,可以轻易的分清定义变量的作用。

    该结构体中只定义了两个数字,num用于表示多项式系数,modulus则是表示第一个指数,当然这里直接将该多项式默认为了一元多项式,后续可以视情况增加。

    随后是创建链表:

    
    
    LinkList GreatList(LinkList head)
    
    {
    
           PNode
    cur=NULL;
    
           PNode
    tail=head;
    
           DataType
    data1,data2;
    
           scanf("%d,%d",&data1,&data2);
    
           while(data1
    != 0 || data2 != 0)
    
           {
    
                  cur=(struct
    Node*)malloc(sizeof(struct Node));
    
                  cur->num=data1;
    
                  cur->modulus=data2;
    
                  
    
                  tail->next=cur;
    
                  tail=cur;
    
                  tail->next=NULL;
    
                  scanf("%d,%d",&data1,&data2);
    
           }
    
           
    
           return head;
    
    }
    
    

    Cur待插入的单链表,head为头,tail为尾,输入(0,0)即为退出,利用循环反复在尾结点之后插入新的结点。这里需要给大家解释一下为什么循环条件里要用“||”即为或,正常思考下不应该用与吗?

    原因如下:

    whiled的判断条件是该条件成立时,进行循环,既while(1)时循环,而当使用“与”时,0“与”0为0,跳出循环,没什么毛病。但是这时候需要注意,加入这时候输入的是(5,0)时,正常而言应该执行循环的,但是5“与”0为0,跳出循环。此时5,0就不会被输入进入单链表,判断条件就由原先的(0,0)中断输入变为了只要存在0,就中断输入了,所以要用“或“,当前后全为0时,既0”或“0时结果才为0,跳出循环。

    随后是输出函数和排序函数,因为没什么可将的便一起放上来了:

    
    
    void SortList(LinkList head)
    
    {
    
           PNode
    p=head->next,q=p->next;
    
           int
    i,j;
    
           
    
           while(p->next
    != NULL)
    
           {
    
                  if(q
    == NULL)
    
                  {
    
                         p=p->next;
    
                         q=p->next;
    
                  }
    
                  else
    if(p->modulus > q->modulus)
    
                  {
    
                         i=p->num;
    
                         j=p->modulus;
    
                         p->num=q->num;
    
                         p->modulus=q->modulus;
    
                         q->num=i;
    
                         q->modulus=j;
    
                  }
    
                  else
    
                  {
    
                         q=q->next;
    
                  }
    
           }
    
           
    
    }
    
     
    
    void PrintLink(LinkList head)    
    
    {
    
           PNode  p = head->next;
    
           while
    (p)
    
           {
    
                  printf("%d,%d
    ", p->num,p->modulus);
    
                  p
    = p->next;
    
           }
    
    }
    
    

    排序函数是以指数从小到大最为顺序排序的,这里说明一下。

    下一个才是重点:多项式的相加函数,这里是以两个多项式相加为基础的:

    
    
    LinkList AddLink(LinkList head1,LinkList
    head2)
    
    {
    
           PNode
    tail=head1,p=head1->next,q=head2->next,i=head2;
    
           
    
           while(p
    != NULL)
    
           {
    
                  if(q
    == NULL)
    
                  {
    
                         tail=p;
    
                         p=p->next;
    
                         i=head2;
    
                         q=head2->next;
    
                  }
    
                  else
    if(p->modulus == q->modulus)
    
                  {
    
                         p->num=p->num+q->num;
    
                         i->next=q->next;
    
                         free(q);
    
                         q=i->next;
    
                  }
    
                  else
    
                  {
    
                         i=q;
    
                         q=q->next;
    
                  }
    
           }
    
           
    
           if(head2->next
    != NULL)
    
           {
    
                  tail->next=head2->next;
    
                  free(head2);
    
           }
    
           
    
           i=head1;
    
           p=head1->next;
    
           
    
           while(p)
    
           {
    
                  if(p->num
    == 0)
    
                  {
    
                         i->next=p->next;
    
                         free(p);
    
                         p=i->next;
    
                  }
    
                  else
    
                  {
    
                         i=p;
    
                         p=p->next;
    
                  }
    
           }
    
           
    
           return head1;
    
    }
    
    

    这里注意两点:

    1、
    我是以传入的第一个多项式作为传出多项式,将第二个多项式加的了第一个里。

    2、
    在相加完之后,我又放了个循环,目的是去掉系数为一的结点。因为考虑到在相加的同时去掉系数为0的结点太难(说白了就是费劲+不会),所以将其分开。

    最后就是主函数了:

    
    
    int main()
    
    {
    
           LinkList
    head=NULL,head1=NULL,head2=NULL;
    
           
    
           head1=SetNullList();
    
           head1=GreatList(head1);
    
           head2=SetNullList();
    
           head2=GreatList(head2);
    
           
    
           SortList(head1);
    
           SortList(head2);
    
           
    
           head=AddLink(head1,head2);
    
           SortList(head);
    
           
    
           PrintLink(head);
    
           
    
           return 0;
    
    }
    
    
    
    
    这里需要注意的是其中我用运用了一个之前没提过的SetNullList函数:
    
    ```c
    
    
    LinkList SetNullList()
    
    {
    
           LinkList
    head = (LinkList)malloc(sizeof(struct Node));
    
           if
    (head != NULL) head->next = NULL;
    
           else
    printf("alloc failure");
    
           return head;
    
    }
    
    
    

    该函数的作用很明显,就是创建一个空链表,随后在运用GreatList函数输入。

    以上便是利用单链表实现多项式加法的全部内容了。做为一个菜鸡萌新就不在这里多bb了,再见!

    更多相关内容
  • C语言链表的入门题,里面提供了两种思路供参考,用链表来实现一元多项式的加减法,并按照一定规律输出。也是练习链表和排序算法的一道小实验,初学链表的小伙伴可以参考参考噢
  • C语言实现单链表方式的一元多项式加法
  • //两个多项式的长度 printf("请输入第一个多项式的项数:"); scanf("%d",&LA); CreatePoly(&A,LA);//因为开始声明的A是野指针,只有地址传递让其指向分配的地址空间 , //声明一个变量时操作系统会分配内存存储...
    #include<stdio.h>
    #include<stdlib.h>
    typedef struct LNode{
    	float coef;
    	int index;
    	struct LNode *next; 
    }LNode,*Polynomial;
    void CreatePoly(Polynomial *AB,int size);
    Polynomial AddPolyn(Polynomial A,Polynomial B);
    void PrintPoly(Polynomial A);
    void main(){
    	Polynomial A,B;//如果在main函数对A初始化分配地址,则可以直接穿A即指向首地址的指针 
    	Polynomial p;
    	int LA,LB;//两个多项式的长度
    	printf("请输入第一个多项式的项数:");
    	scanf("%d",&LA); 
    	CreatePoly(&A,LA);//因为开始声明的A是野指针,只有地址传递让其指向分配的地址空间 , 
    	//声明一个变量时操作系统会分配内存存储该变量,指针也是变量 
    	//&A即指针存放A的地址,而不是A指向的地址,A是野指针,指向地址未知 
    	PrintPoly(A);
    	printf("请输入第二个多项式的项数:");
    	scanf("%d",&LB);
    	CreatePoly(&B,LB); 
    	PrintPoly(B);
    	p = AddPolyn(A,B);//经过创建A已经不是野指针,而是指向单链表,故此处可直接穿指针
    	printf("和多项式为:"); 
    	PrintPoly(p);
    } 
    
    void CreatePoly(Polynomial *AB,int size){//多项式的项数 //*AB是双重指针 
    	*AB = (Polynomial)malloc(sizeof(LNode));//分配头结点 //此时*AB就和mian中的A等价,即指针AB指向了存放A的地址 *AB=A;对*AB初始化即相当于对A初始化 
    //AB=&A;*AB=A;即初始化让A指向了分配的空间	
    	LNode *r,*s;
    	r = *AB;
    	int i = 0;
    	for(i=0;i<size;i++){
    		s = (LNode*)malloc(sizeof(LNode));
    		printf("请输入系数和指数(空格隔开):");//scanf会跳过空格,逗号会产生错误 
    		scanf_s("%f %d",&s->coef,&s->index); 
    		r->next = s;
    		r = s;
    	} 
    	r->next = NULL;
    	
    	
    }
    void PrintPoly(Polynomial A){
    	LNode *p;
    	p = A->next;
    	while(p){
    		printf("%.2f X^%d",p->coef,p->index);
    		//将多项式连接起来显示,最后一个结点无符号故在每一个结点之前输出加减号 
    		p = p->next; 
    		if(p!=NULL){
    			if(p->coef>=0)
    				printf("+");
    			else
    				printf("-");
    		} 
    	}
    	printf("\n");
    } 
    Polynomial AddPolyn(Polynomial A,Polynomial B){
    	LNode *a,*b;//分别指向A,B 
    	LNode *Deletea,*Deleteb;//用来指向系数为0时要释放的结点 
    	a = A->next;
    	b = B->next; 
    	Polynomial C;
    	LNode *Crear;//指针,用来指向和多项式的头和尾
    	//可以考虑给C一个头结点,
    	C = (Polynomial)malloc(sizeof(LNode));
    	C->next  = NULL;
    	Crear =  C; 
    	while(a!=NULL&&b!=NULL){
    		if((a->index)<(b->index)){
    			Crear->next = a;
    			Crear = a;
    			a = a->next;
    		}//if
    		else if(a->index==b->index){
    			if(a->coef+b->coef==0){
    				 Deletea = a;
    				 a = a->next;
    				 Deleteb = b;
    				 b = b->next;
    				 free(Deletea);
    				 free(Deleteb); 
    			}//if
    			else{ 
    				a->coef+=b->coef;//两个结点合并为一个,删除一个 
    				Crear->next = a;
    				Crear = a;
    				Deleteb = b;
    				b = b->next;				
    				a = a->next;
    				free(Deleteb);
    			}//else
    		}
    		else{
    			Crear->next = b;
    			Crear = b;
    			b = b->next;
    		}
    	}//while 
    //一轮处理结束一个多项式以全部处理还有一个未处理完 注意上面以经->next 
    	while(a!=NULL){
    		Crear->next = a; 
    		Crear = a;
    		a =a->next; 
    	}
    	while(b!=NULL){
    		Crear->next = b;
    		Crear = b;
    		b =b->next; 
    	}		
    	return C;
    //	Crear = Chead = NULL;//C不带头结点太复杂 
    //	while(a!=NULL&&b!=NULL){
    //		if(a->index<b->index){
    //			if(Chead==NULL){//没有头结点直接第一个结点需单独处理 
    //				Chead = a;
    //				Crear = a; 
    //			}
    //			else{
    //				Crear->next = a;//将小阶结点插入C 
    //			}
    //			a  = a->next;
    //		}
    //		else if(a->index==b->index){
    //			if(a->coef+b->coef==0){
    //				 Deletea = a;
    //				 a = a->next;
    //				 Deleteb = b;
    //				 b = b->next;
    //				 free(Deletea);
    //				 free(Deleteb); 
    //			}
    //			else{
    //				if(Chead==NULL){//没有头结点直接第一个结点需单独处理 
    //					a->coef+=b->coef;//两个结点合并为一个,删除一个 
    //					Chead = a;
    //					Crear = a; 
    //					Deleteb = b;
    //					b = b->next;
    //					a = a->next;
    //					free(Deleteb);
    //				}
    //				else{
    //					Crear->next = a;//将小阶结点插入C 
    //				}
    //				a  = a->next;
    //			}
    //		}
    //	} 
    
    
    }
    
    展开全文
  • 设有一元多项式Am(x)和Bn(X),编程实现多项式Am(x)和Bn(x)的加法、减法和乘法运算。其中多项 式描述为: Am(x)=A0+A1x1+A2x2+A3x3+….+Amxm; Bn(x)=B0+B1x1+B2x2+B3x3+….+Bnxn。 程序源代码: DS.h #include <...

    一元多项式计算器


    一、实验目的
    1.掌握顺序表和单链表的存储特点及插入、删除等算法。
    2.灵活运用顺序表和单链表的相关算法实现一元多项式的计算。

    二、 实验内容及要求
    任务描述
    设有一元多项式Am(x)和Bn(X),编程实现多项式Am(x)和Bn(x)的加法、减法和乘法运算。其中多项 式描述为:

    Am(x)=A0+A1x1+A2x2+A3x3+….+Amxm;
    Bn(x)=B0+B1x1+B2x2+B3x3+….+Bnxn。

    程序源代码:

    DS.h

    #include <stdio.h>
    #include <string.h>
    #include <stdlib.h>
    #define TRUE 1
    #define FALSE 0
    #define OK 1
    #define ERROR 0
    typedef int Status;
    

    LinkList.h

    #include <DS.h>
    typedef struct LNode
    {
        int data;
        int index;
        struct LNode *next;
    }LNode, *LinkList;
    
    LinkList makeList();  //生成一个空链表
    void Insert(LinkList L, int data, int index);  //添加
    void Delete(LinkList L, LinkList position);    //删除
    LinkList Find(LinkList L, int index);          //查找
    LinkList makeFirstList();   //输入第一个多项式
    LinkList makeSecondList();  //输入第二个多项式
    LinkList sum(LinkList L1, LinkList L2);   //加法
    LinkList sub(LinkList L1, LinkList L2);   //减法
    LinkList mul(LinkList L1, LinkList L2);   //乘法
    int getFlag();    //排序方式
    void ascOrder(LinkList L);      //升幂排列
    void descOrder(LinkList L);     //降幂排列
    void exportResult(LinkList L,int flag);   //输出结果
    
    

    LinkList.c

    #include <LinkList.h>
    
    LinkList makeList()
    {
        LinkList L = (LinkList)malloc(sizeof(struct LNode));
        L->data = 0;
        L->index = 0;
        L->next = NULL;
        return L;
    }
    
    void Insert(LinkList L,int data,int index)
    {
        LinkList p = L;
        LinkList q = (LinkList)malloc(sizeof(struct LNode));
        q->next = NULL;
        q->data = data;
        q->index = index;
        q->next = p->next;
        p->next = q;
    }
    
    void Delete(LinkList L,LinkList position)
    {
        LinkList p = L->next;
        LinkList q = L;
        while (p)
        {
            if (p == position)
            {
                q->next = p->next;
                free(p);
                break;
            }
            q = p;
            p = p->next;
        }
    }
    
    LinkList Find(LinkList L, int index)
    {
        LinkList p = L->next;
        while (p)
        {
            if (p->index == index)
            {
                return p;
            }
            p = p->next;
        }
        return NULL;
    }
    
    LinkList makeFirstList()
    {
        int n,data,index;
        LinkList L1 = makeList();
        printf("*************欢迎使用一元多项式计算器*************\n\n");
        printf("请输入第一个多项式的项数:\n");
        scanf("%d",&n);
        printf("请输入第一个多项式:\n");
        //printf("(注意:1^2+2^3 应表示为 1 2 2 3, 后面同理)\n");
        for(int i=0; i<n; i++)
        {
            scanf("%d",&data);
            scanf("%d",&index);
            if(data != 0)
            {
                Insert(L1,data,index);
            }
        }
        return L1;
    }
    
    LinkList makeSecondList()
    {
        int n,data,index;
        LinkList L2 = makeList();
        printf("请输入第二个多项式的项数:\n");
        scanf("%d",&n);
        printf("请输入第二个多项式:\n");
        for(int i=0; i<n; i++)
        {
            scanf("%d",&data);
            scanf("%d",&index);
            if(data != 0)
            {
                Insert(L2,data,index);
            }
        }
        return L2;
    }
    
    LinkList sum(LinkList L1,LinkList L2)
    {
        int data;
        LinkList L3 = makeList();
        LinkList p1 = L1->next;
        LinkList p2 = L2->next;
        LinkList p;
        LinkList q;
        while(p1!=NULL)
        {
            p = Find(L2,p1->index);
            if(p!=NULL)
            {
                data = p1->data + p->data;
                if(data == 0) {}
                else
                    Insert(L3,data,p1->index);
                q = p1;
                p1 = p1->next;
                Delete(L1,q);
                Delete(L2,p);
            }
            else
            {
                Insert(L3,p1->data,p1->index);
                q = p1;
                p1 = p1->next;
                Delete(L1,q);
            }
        }
        p1 = L1->next;
        p2 = L2->next;
        while(p2!=NULL)
        {
            q = Find(L1,p2->index);
            if(q!=NULL)
            {
                data = p2->data + q->data;
                Insert(L3,data,p2->index);
                p = p2;
                p2 = p2->next;
                Delete(L2,p);
                Delete(L1,q);
            }
            else
            {
                Insert(L3,p2->data,p2->index);
                p = p2;
                p2 = p2->next;
                Delete(L2,p);
            }
        }
        return L3;
    }
    
    LinkList sub(LinkList L1,LinkList L2)
    {
        LinkList L3 = makeList();
        LinkList p2 = L2->next;
        while(p2!=NULL)
        {
            p2->data = (-1) * p2->data;
            p2 = p2->next;
        }
        L3 = sum(L1,L2);
        return L3;
    }
    
    LinkList mul(LinkList L1,LinkList L2)
    {
        int data,index;
        LinkList L3  = makeList();
        LinkList p1 = L1->next;
        LinkList p2 = L2->next;
        LinkList p;
        while(p1!=NULL)
        {
            p2 = L2->next;
            while(p2!=NULL)
            {
                data = p1->data * p2->data;
                index = p1->index + p2->index;
                p = Find(L3,index);
                if(data == 0)
                {
                    p2 = p2->next;
                    continue;
                }
                if(p!=NULL)
                {
                    p->data += data;
                }
                else
                {
                    Insert(L3,data,index);
                }
                p2 = p2->next;
            }
            p1 = p1->next;
        }
        return L3;
    }
    
    int getFlag()
    {
        int flag;
        printf("请输入排序方式:\n");
        printf("0.升幂\n");
        printf("1.降幂\n");
        scanf("%d",&flag);
        return flag;
    }
    
    void descOrder(LinkList L)
    {
        int data,index;
        LinkList p1 = L->next;
        LinkList p2 = L->next;
        while(p1!=NULL)
        {
            p2 = L->next;
            while(p2!=NULL)
            {
                if(p1->index > p2->index)
                {
                    data = p1->data;
                    index = p1->index;
                    p1->data = p2->data;
                    p1->index = p2->index;
                    p2->data = data;
                    p2->index = index;
                }
                p2 = p2->next;
            }
            p1 = p1->next;
        }
    }
    
    void ascOrder(LinkList L)
    {
        int data,index;
        LinkList p1 = L->next;
        LinkList p2 = L->next;
        while(p1!=NULL)
        {
            p2 = L->next;
            while(p2!=NULL)
            {
                if(p1->index < p2->index)
                {
                    data = p1->data;
                    index = p1->index;
                    p1->data = p2->data;
                    p1->index = p2->index;
                    p2->data = data;
                    p2->index = index;
                }
                p2 = p2->next;
            }
            p1 = p1->next;
        }
    }
    
    void exportResult(LinkList L,int flag)
    {
        if(flag == 0)
        {
            ascOrder(L);  //升幂排列
        }
        else if(flag == 1)
        {
            descOrder(L);  //降幂排列
        }
        printf("运算的结果为:\n");
        LinkList p = L->next;
    
    
        if(!p)
        {
            printf("0 0");//零多项式输出0 0
        }
        else
        {
            while(p)
            {
                //只有项的系数不为0时才能输出
                if(p->data != 0)
                {
                    //当指数为0时,只输出系数
                    if(p->index==0) printf("%d",p->data);
                    //系数和指数都为1,输出x
                    else if(p->data == 1 && p->index == 1) printf("x");
                    //系数为-1,指数为1,输出-x
                    else if(p->data == -1 && p->index == 1) printf("-x");
                    //系数为1,指数不为1,不输出系数
                    else if(p->data == 1 && p->index != 1) printf("x^%d",p->index);
                    //系数为-1,但是指数不为1,系数只输出-
                    else if(p->data == -1 && p->index != 1) printf("-x^%d",p->index);
                    //系数不是1或-1,指数为1,不输出指数
                    else if((p->data != 1 || p->data != -1) && p->index == 1)  printf("%dx",p->data);
                    //系数不是1或-1,指数不为1,系数和指数都输出
                    else if((p->data != 1 || p->data != -1) && p->index != 1)  printf("%dx^%d",p->data,p->index);
    
                    //如果有下一项且下一项的系数为大于0的数,则输出+
                    if(p->next && p->next->data > 0) printf("+");
                    p = p->next;
                }
            }
        }
        printf("\n");
    }
    

    main.c

    #include <LinkList.h>
    int main()
    {
        char p;
        int flag;
        LinkList L1 = makeFirstList();
        LinkList L2 = makeSecondList();
        printf("请输入想要进行的运算:\n");
        getchar();
        scanf("%c",&p);
        flag = getFlag();
        switch(p)
        {
        case '+':
            //printf("进行了加法运算!!!\n");
            exportResult(sum(L1,L2),flag);
            break;
        case '-':
            //printf("进行了减法运算!!!\n");
            exportResult(sub(L1,L2),flag);
            break;
        case '*':
            //printf("进行了乘法运算!!!\n");
            exportResult(mul(L1,L2),flag);
            break;
        }
        return 0;
    }
    
    

    测试:
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    在这里插入图片描述
    求个赞。。。

    展开全文
  • 输入:第一个一元多项式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&...

    输入:第一个一元多项式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>
    #include <stdlib.h>
    
    typedef struct LinkNode{
    	int coef;//系数
    	int index;//指数
    	struct LinkNode *next; 
    }LinkNode,*LinkList; 
    
    LinkList createLinkNode(){
    	LinkList L=(LinkList) malloc(sizeof(LinkNode));
    	L->next=NULL;	
    	printf("请输入多项式(系数,指数):");
    	LinkNode *q=L,*p;
    	int coef,index;
    	scanf("%d,%d",&coef,&index);
    	while(!(coef==0&&index==0)){
    		p=(LinkNode *)malloc(sizeof(LinkNode));
    		p->next=NULL;
    		p->coef=coef;
    		p->index=index;
    		q->next=p;
    		q=p;
    		printf("请继续输入多项式(系数,指数):");
    		scanf("%d,%d",&coef,&index);
    	}
    	return L;
    }
    
    void add(LinkList &L1,LinkList &L2){
    	LinkNode *p1,*temp;
    	while(L2->next!=NULL){
    		p1=L1;
    		while(p1->next!=NULL&&p1->next->index!=L2->next->index){
    			p1=p1->next;
    		}
    		temp=L2->next;
    		L2->next=temp->next;
    		temp->next=NULL;
    		if(p1->next==NULL){
    			temp->next=p1->next;
    			p1->next=temp;
    		}else{
    			p1->next->coef+=temp->coef;
    			free(temp);
    			if(p1->next->coef==0){
    				temp=p1->next;
    				p1->next=temp->next;
    				free(temp);
    			}
    		}
    	}
    	free(L2);
    }
    
    int main(){
    	LinkList L1=createLinkNode();
    	LinkList L2=createLinkNode();
    	add(L1,L2);
    	LinkNode *p=L1->next;
    	if(p==NULL)return 0;
    	while(p!=NULL&&p->next!=NULL){
    		printf("%dx^%d+",p->coef,p->index);
    		p=p->next;
    	}
    	if(p!=NULL)printf("%dx^%d",p->coef,p->index);
    	return 0;
    }

    展开全文
  • 一元多项式加法减法乘法运算的实现 1.1设计内容及要求 1)设计内容 1使用顺序存储结构实现多项式加减乘运算 例如 , 求和结果 2使用链式存储结构实现多项式加减乘运算 求和结果 2设计要求 1用C语言编程实现上述实验...
  • 完美的数据结构大作业之选。C语言+链表 实现。不用提前知道多项式项数,可以自动排序,可以合并同类项,可以进行加法、乘法运算。VS环境可运行,其他编程软件找到cpp复制粘贴即可
  • 一元多项式的加减法(C语言

    千次阅读 2022-03-20 14:26:28
    C语言实现一元多项式的加减法
  • C语言实现一元多项式加法与乘法

    千次阅读 2022-04-06 15:04:54
    题目来源:PTA 数据结构与算法题目集(中文)7-2 一元多项式的乘法与加法运算 (20 分) 一、程序结果 二、实现步骤与程序说明 1.问题分析 题目涉及稀疏多项式的运算,相较于顺序存储结构,采用链式存储结构更为灵活...
  • 数据结构 C语言 动态链表 议员多项式的加减法 数据结构C语言 一元多项式的加减法算法实现 代码,用vs运行,已测试成功运行,
  • C语言实现一元多项式加法运算

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

    千次阅读 多人点赞 2019-04-14 19:32:12
    一元多项式加法和乘法(C语言链表实现) 题目 总体结构: main函数ReadPolyAttachAddMultcomparePrintPoly 各函数解释: 函数名 负责功能 ReadPoly 读入数据 Attach 将数据构建成...
  • 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) {...
  • } // 显示菜单 void Menu() { printf("\t\t\t\t\t欢迎使用一元稀疏多项式加法计算器!\n"); printf("\t\t\t\t\t\t******菜单******\n"); printf("\t\t\t\t\t\t* *\n"); printf("\t\t\t\t\t\t* 1.开始计算 *\n")...
  • C语言一元多项式相加(链表)

    万次阅读 多人点赞 2020-10-30 21:10:52
    今天写一个关于一元多项式相加的程序,就当是在练习运用一下链表的知识。首先,我们先来分析一波,一元多项式相加,首先要用链表创建两个或多个多项式,每个节点里的数据有两个,系数和指数;其次,如果要实现乱幂...
  • 一元多项式加法减法乘法运算的实现 1.1设计内容及要求 1)设计内容 1使用顺序存储结构实现多项式加减乘运算 例如 , 求和结果 2使用链式存储结构实现多项式加减乘运算 求和结果 2设计要求 1用C语言编程实现上述实验...
  • 《数据结构课程设计—一元多项式加法、减法、乘法运算的实现》由会员分享,可在线阅读,更多相关《数据结构课程设计—一元多项式加法、减法、乘法运算的实现(20页珍藏版)》请在人人文库网上搜索。1、1.一元多项式...
  • C语言一元多项式加法//C语言数据结构_一元多项式加法#include #include #include #define OK 1#define ERROR 0typedef int Status;typedef int ElemType;typedef struct LNode //定义结构体{ElemType coef;ElemType ...
  • 实现两个多项式加法 目录题目计算两个多项式之和代码逻辑数据结构合并同类项合并两个式子主函数逻辑运行结果代码 题目计算两个多项式之和 例子: f(x)=2x3+9x6+2x8 f(x)= 2x^3 + 9 x^6+2x^8 f(x)=2x3+9x6+2x8 + f(x)...
  • 设计函数分别求两个一元多项式的乘积与和。 输入格式: 输入分2行,每行分别先给出多项式非零项的个数,再以指数递降方式输入一个多项式非零项系数和指数(绝对值均为不超过1000的整数)。数字间以空格分隔。 输出...
  • 题目描述 编程实现一元多项式加法运算。(要求用链表实现) 输入 第一行为一元多项式A, 以 0,0 作为输入结束; 第二行为一元多项式B, 以 0,0 作为输入结束。 输出 多项式A和多项式B的和。
  • 问题遇到的现象和发生背景 求各位解答一下下面这个求一元多项式加法函数的时间复杂度和空间复杂度问题 问题相关代码,请勿粘贴截图 Linklist PolyAdd(Linklist L1, Linklist L2) { Linklist head, pa, pb, s, p;...
  • 用顺序存储结构实现一元多项式加法、减法和乘法
  • 一元多项式的加减 c语言链表实现

    千次阅读 2020-06-20 17:14:15
    一元多项式的加减 c语言链表实现 1.题目 实现一元多项式的加减法运算,要求多项式采用链表存储结构。 2.测试用例 (1)a(x)=3x^1000 +7x^3-2x+1 b(x)=x^99 -x^3+2x+8 加法运算结果: c(x)=9.00 +6.00x^3 +1.00x^99 +...
  • C语言实现一元多项式加法运算(链表)

    千次阅读 多人点赞 2019-10-05 21:26:25
    C语言实现一元多项式加法运算(链表) 完成如下操作: ①输入并建立一元稀疏多项式;(输入格式自定) 例如:4 - 12x3 + 123x5 - 80x10 ②输出所建立的一元多项式;(输出格式自定) 例如:12 - 3x + x3 + 230x12 ③...
  • 数据结构经典案例,一元多项式加法
  • 一、概述通过C语言使用链式存储结构实现一元多项式加法、减法和乘法的运算。按指数降序排列。二、需求分析建立一元多项式并按照指数降序排列输出多项式,将一元多项式输入并存储在内存中,能够完成两个多项式的加减...
  • 基于c语言实现,为了使用&引用,引入了c++头文件 源代码 #include <iostream> #include <stdlib.h> typedef struct Polynode{ int coef,exp; struct Polynode *next; }Polynode,*Polylist; ...
  • typedef struct polynomial//多项式的每一项结构{ double coefficient;//系数 int index;//指数 struct polynomial *next;//指针->指向下一个节点}node;struct polynomial *create();//创建链表void sort(struct ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 819
精华内容 327
关键字:

一元多项式加法c语言

友情链接: mifa.rar