精华内容
下载资源
问答
  • 一元多项式计算

    2013-01-28 12:40:20
    一元多项式计算&over; 数据结构课程设计
  • 一元多项式计算机

    2019-08-19 16:05:26
    一元多项式计算机 一,目的 掌握顺序表和单链表的存储特点及插入、删除等算法。 二,描述 设有一元多项式Am(x)和Bn(X),编程实现多项式Am(x)和Bn(x)的加法、减法和乘法运算。其中多项式描述为: Am(x)=A0+...

    一元多项式计算机

    一,目的

    掌握顺序表和单链表的存储特点及插入、删除等算法。

    二,描述

    设有一元多项式Am(x)和Bn(X),编程实现多项式Am(x)和Bn(x)的加法、减法和乘法运算。其中多项式描述为:

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

    (1)输入:

    从键盘输入运算指令(相加、相减、相乘),根据运算指令进行相应运算;

    ​ 从键盘输入两个多项式的系数和指数;

    ​ 系数和指数采用int类型,运算结果不超出int取值范围。

    (2)输出:

    ​ 每种运算结果以多项式形式输出,要输出升幂和降幂两种情况。

    ​ 结果多项式中无重复阶项、无零系数项,输出多项式时请采用如下易读形式(一元多项式,总变元为x): x^4 - 3 x^2 + 5

    三,测试方案

    多项式一多项式二
    加法3+2x^5 +5x^3 -8x^-14x^2 -2x^-1 +9x^3
    减法-3x^2 +4x^-5+7-5x^2 +9x^4 -7x^-5+7
    乘法3+7x^5 +6x^-34x^-5 +5x^2 +7x^4
    • 加法加法
    • 减法
      减法
    • 乘法
      乘法

    四,程序源码

    DS.h

    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    #include <math.h>
    
    #define TRUE 1
    #define FALSE 0
    #define OK 1
    #define ERROR 0
    
    //Status 是函数类型,其值是函数结果状态码 
    typedef int Status;
    

    LinkList.h

    #include "DS.h"
    
    typedef struct{
    	float coef;
    	int expn;
    }term, ElemType;
    
    typedef struct LNode
    {
        ElemType  data;
    	struct LNode *next;
    }LNode,*Link,*Position;
    
    typedef struct{
    	Link head, tail;
    	int len;
    }LinkList;
     
    typedef LinkList polynomial;
    
    void menu();
    void CreatPolyn(polynomial &P, int m);  //输入m项的系数和指数,表示一元多项式的有序链表P 
    void DestroyPolyn(polynomial &P);  //销毁一元多项式P 
    void PrintPolyn(polynomial P);  //打印出一元多项式P 
    void Reverse_Linklist(polynomial L);  //倒置 
    int PolynLength(polynomial P);  //返回一元多项式P的项数 
    int cmp(term a, term b); 
    Status InitList(LinkList &P);          //构造一个空的线性链表 
    Link GetHead(LinkList L);  //返回线性表L的头结点位置 
    Status LocateElem(polynomial P, ElemType e, Link &q, int(*compare)(ElemType, ElemType));
    Status MakeNode(Link &p, ElemType e); //分配由p指向的值为e的节点 
    Status InsFirst(Link h, Link s);  //已知h指向线性链表的头节点,将s所指的节点插入在第一个节点之前 
    Position NextPos(LinkList P, Link l);  //已知P指向线性表L中的一个节点,返回p所指节点的直接后继位置 
    ElemType GetCurElem(Link p);   //已知p指向线性链表中的一个节点,返回p所指节点中数据元素的值 
    Status SetCurElem(Link &p, ElemType e);  //已知p指向线性链表中的一个节点,用e更新p所指节点中数据元素的值
    Status DelFirst(Link h, Link &q);  //已知h指向线性链表的头结点,删除线性链表的第一个节点并以q返回 
    void FreeNode(Link &p);     //清空节点p 
    Status Append(LinkList &L, Link s); 
    Status ListEmpty(LinkList L);  //若l是空表返回TURE 
    void AddPolyn(polynomial &Pa, polynomial &Pb);  //多项式相加 
    void SubtractPolyn(polynomial &Pa, polynomial &Pb);  //多项式相减 
    void MultiplyPolyn(polynomial &Pa, polynomial &Pb);  //多项式相乘 
    

    LinkList.cpp

    #include "LinkList.h"
    
    void menu()
    {
        printf(" 一元多项式计算器   输入'0'退出\n\n");
        printf("\t1.加法\n");
        printf("\t2.减法\n");
        printf("\t3.乘法\n\n");
    }
    
    Status InitList(LinkList &P)          
    {//构造一个空的线性链表 
    	if((P.head = P.tail = (Link)malloc(sizeof(LNode))) == NULL)
    	{
    		printf("不能分配空间\n");
    	}
    	P.len = 0;
    	P.head->next = NULL;
    	return OK;
    }
    
    void CreatPolyn(polynomial &P, int m)
    {//创建一元多项式 
    	Link h, s = NULL ;
    	ElemType e;
    	Link q = (Link)malloc(sizeof(LNode)) ;
    	Link last = (Link)malloc(sizeof(LNode)) ;
    
    	InitList(P); h = GetHead(P);
    	e.coef = 0.0; e.expn = -1; 
    	SetCurElem(h, e);
    	
    	for(int i=1; i<=m; ++i){
    		scanf("%f%d",&e.coef,&e.expn);
    		
    		switch(LocateElem(P,e,q,cmp))
    		{
    		case 0 :
    			break ;
    			
    		case 1 :
    			if(MakeNode(s,e))
    			{
    				if(InsFirst(q,s))
    				{
    					P.len++ ;
    				}
    			}
    			break ;
     
    		case -1 :
    			if(MakeNode(s,e))
    			{
    				last = P.tail ;
    				
    				last->next = s ;
    				
    				P.tail = s ;
     
    				P.len++ ;			
    			}                
    			break ;
    		}
    	}
    }
    
    void DestroyPolyn(polynomial &P)
    {//销毁一元多项式P 
    //	Link h = (Link)malloc(sizeof(LNode));
    	Link h = P.head;
    	Link temp;
    	while(h!= NULL)
    	{
    		temp = h;
    		h = h->next;
    		free(temp);
    	}
    }
    
    void PrintPolyn(polynomial P)
    {//打印出一元多项式P 
    	Link h = P.head->next;
    	printf("%.1fx^%d",h->data.coef,h->data.expn);
    	h = h->next;
    	while(h !=NULL)
    	{
    		if(h->data.coef >= 0)
    			printf("+%.1fx^%d",h->data.coef,h->data.expn);
    		else
    			printf("%.1fx^%d",h->data.coef,h->data.expn);
    			
    		h = h->next;
    	}
    	printf("\n\n\n");
    }
    
    void Reverse_Linklist(polynomial L)
    {//倒置 
        Link p, q ;
        p = L.head->next;
        L.head->next = NULL;
        while(p)
        {
        	q = p;
        	p = p->next;
        	q->next = L.head->next;
        	L.head->next = q;
    	}
    }
    
    int PolynLength(polynomial P)
    {//返回一元多项式P的项数 
    	return P.len;
    }
    
    
    int cmp(term a, term b)
    {
    	if(a.expn==b.expn)
    	return 0 ;
    	else
    	return (a.expn-b.expn)/abs(a.expn-b.expn);
    }
    
    
    
    Link GetHead(LinkList L) 
    {//返回线性表L的头结点位置 
    	return L.head;
    }
    
    Status LocateElem(polynomial P, ElemType e, Link &q, int(*compare)(ElemType, ElemType))
    {
    	Link pre = (Link)malloc(sizeof(LNode));
    	Link temp = (Link)malloc(sizeof(LNode));
    	ElemType t;
    	
    	temp = P.head->next; 
    	pre = P.head; 
    	
    	while(temp != NULL)
    	{
    		t = temp->data;
    		switch((*compare)(t,e))
    		{
    			case 1://t>e 
    				q = pre;
    				return 1;
    				break;
    				
    			case 0://相同 
    				return 0;
    				break ;
    		}
    		pre = pre->next;
    		temp = temp->next ;
    	}
    	return -1;
    }
    
    Status MakeNode(Link &p, ElemType e)
    {//分配由p指向的值为e的节点 
    	if((p= (Link)malloc(sizeof(LNode))) != NULL)
    	{
    		p->data = e;
    		p->next = NULL;
    		return TRUE;
    	}
    	return FALSE;
    }
    
    Status InsFirst(Link h, Link s)
    { //已知h指向线性链表的头节点,将s所指的节点插入在第一个节点之前 
    	Link temp;
    	if((temp = (Link)malloc(sizeof(LNode))) != NULL)
    	{
    		temp = h->next;
    		s->next = temp;
    		h->next = s;
    		return OK;
    	}
    	return FALSE;
    }
    
    Position NextPos(LinkList P, Link l)
    {//已知l指向线性表P中的一个节点,返回l所指节点的直接后继位置 
    	Link cur = P.head;
    	while(cur != l && cur != NULL)
    		cur = cur->next;
    	if(cur == NULL)
    	return NULL;
    	else
    	return cur->next;
    }
    
    ElemType GetCurElem(Link p)
    {//已知p指向线性链表中的一个节点,返回p所指节点中数据元素的值 
    	return p->data;
    }
    
    Status SetCurElem(Link &p, ElemType e)
    {//已知p指向线性链表中的一个节点,用e更新p所指节点中数据元素的值
    	if(p == NULL)
    	{
    		printf("Error\n");
    		return ERROR;
    	}
    	else
    	{
    		p->data = e;
    		return OK;
    	}
    }
    
    Status DelFirst(Link h, Link &q)
    {//已知h指向线性链表的头结点,删除线性链表的第一个节点并以q返回 
    	Link temp;
    	if(NULL == h->next){
    		q = NULL;
    		return ERROR;
    	}
    	temp = h->next;
    	h->next = h->next->next;
    	q = temp;
    	return OK;
    }
    
    void FreeNode(Link &p)
    {//清空节点p 
    	if(p != NULL){
    	free(p);
    	p = NULL;
    	} 
    }
    
    Status Append(LinkList &L, Link s)
    {
    	int count = 0;
    	L.tail->next = s;
    	while(s != NULL)
    	{
    		L.tail = s;
    		s = s->next;
    		count++;
    	}
    	L.len += count;
    	
    	return TRUE;
    }
    
    Status ListEmpty(LinkList L)
    {//若l是空表返回TURE 
    	if(L.head == L.tail)
    	return TRUE;
    	else
    	return FALSE;
    }
    
    
    void AddPolyn(polynomial &Pa, polynomial &Pb) {
    	Link ha, hb, qa, qb;
    	term a, b;
    	ha = GetHead(Pa); hb = GetHead(Pb); //ha和hb分别指向Pa和Pb的头结点 
    	qa = NextPos(Pa,ha); qb = NextPos(Pb,hb); //qa和qb分别指向ha和hb中的后继 
    	while(qa && qb){
    		a = GetCurElem(qa); b = GetCurElem(qb);
    		switch(cmp(a, b)){
    			case -1:  //多项式Pa中当前节点的指数值小
    				ha = qa;  qa = NextPos(Pa, qa);  break; 
    			
    			case 0 :  //两者指数相等
    				a.coef  = a.coef + b.coef;
    				if(a.coef != 0.0){ 
    					SetCurElem(qa, a);  ha = qa;} 
    				else{
    					if(DelFirst(ha, qa)) Pa.len--;
    					FreeNode(qa);
    					}
    				DelFirst(hb, qb); FreeNode(qb);
    				qb = NextPos(Pb, hb);  qa = NextPos(Pa, ha);
    				break;
    			case 1:
    				DelFirst(hb, qb); InsFirst(ha, qb);
    				qb = NextPos(Pb, hb); ha = NextPos(Pa, ha); 
    				break;
    		} 
    	} 
    	if(!ListEmpty(Pb))  Append(Pa, qb);
    	FreeNode(hb);
    }
    
    void SubtractPolyn(polynomial &Pa, polynomial &Pb){
    	Link ha, hb, qa, qb;
    	term a, b;
    	ha = GetHead(Pa); hb = GetHead(Pb); //ha和hb分别指向Pa和Pb的头结点 
    	qa = NextPos(Pa,ha); qb = NextPos(Pb,hb); //qa和qb分别指向ha和hb中的后继 
    	while(qa && qb){
    		a = GetCurElem(qa); b = GetCurElem(qb);
    		switch(cmp(a, b)){
    			case -1:  //多项式Pa中当前节点的指数值小
    				ha = qa;  qa = NextPos(Pa, qa);  break; 
    			
    			case 0 :  //两者指数相等
    				a.coef  = a.coef - b.coef;
    				if(a.coef != 0.0){ 
    					SetCurElem(qa, a);  ha = qa;} 
    				else{
    					if(DelFirst(ha, qa)) Pa.len--;
    					FreeNode(qa);
    					}
    				DelFirst(hb, qb); FreeNode(qb);
    				qb = NextPos(Pb, hb);
    				qa = NextPos(Pa, ha);
    				break;
    			case 1 : //多项式Pb中当前节点的指数值小
    				b.coef = -b.coef;
    				SetCurElem(qb, b);
    				DelFirst(hb, qb); InsFirst(ha, qb);
    				qb = NextPos(Pb, hb); ha = NextPos(Pa, ha); 
    				break;
    		} 
    	} 
    	if(!ListEmpty(Pb)){
    	while(qb != NULL){
    		qb->data.coef = -qb->data.coef;
    		qb = NextPos(Pb, qb);
    	}
    	qb = hb->next;
    	Append(Pa, qb);
    	FreeNode(hb);
    }
    } 
     
    
    void MultiplyPolyn(polynomial &Pa, polynomial &Pb){
    	Link s, pa, pb, haa, hbb;
    	pa = Pa.head->next; pb = Pb.head->next;
    	ElemType e;
    	polynomial Paa, Pbb;
    	
    	InitList(Paa);
    	haa = GetHead(Paa);
    	haa->data.coef = 0.0; haa->data.expn = -1;
    	
    	for(int i=1; i<=Pa.len; i++){//新建一个多项式Paa,把Pa的值复制进去 
    		e.coef = pa->data.coef; 
    		e.expn = pa->data.expn;
    		MakeNode(s, e);  InsFirst(haa, s);
    		haa = haa->next;
    		
    		pa = pa->next; 
    		Paa.len++ ;	
    		Paa.tail = haa;
    	}
    	
    	int num = Pa.len;
    	
    	for(int i=1; i<=Pb.len; i++){
    		pa = Paa.head->next;
    		InitList(Pbb);
    		hbb = GetHead(Pbb);
    		hbb->data.coef = 0.0; hbb->data.expn = -1;
    		
    		for(int j=0; j<num; j++){//把Pa与Pb的乘积放在Pbb里 
    			e.coef = pa->data.coef * pb->data.coef;
    			e.expn = pa->data.expn + pb->data.expn;
    			MakeNode(s, e);
    			InsFirst(hbb, s);
    			hbb = hbb->next;
    			pa = pa->next;
    			
    			Pbb.tail = hbb ;
    			Pbb.len++ ;			             
    		}
    		AddPolyn(Pa, Pbb);//把Pbb的值加到Pa里 
    		DelFirst(Pb.head, pb);
    		FreeNode(pb);
    		pb = NextPos(Pb,Pb.head);
    	}
    	SubtractPolyn(Pa, Paa);	//减去Pa里初始的Paa值 
    }
    

    main.cpp

    #include "LinkList.h"
    
    int main()
    {
        int choice;
        while(1)
        {
            menu();
            int m;
            polynomial Pa, Pb;
            printf("请输入算指令: ");
            scanf("%d",&choice);
            switch(choice)
            {
            	case 1://加法 
            		
            		printf("请输入多项式A的项数: ");
            		scanf("%d", &m); 
            		printf("请输入%d对系数指数:\n ",m);
            		CreatPolyn(Pa, m);
            		PrintPolyn(Pa); 
            		
            		printf("请输入多项式B的项数: ");
            		scanf("%d", &m); 
            		printf("请输入%d对系数指数:\n ",m);
            		CreatPolyn(Pb, m);
            		PrintPolyn(Pb);
            		
            		AddPolyn(Pa, Pb);
            		printf("==运算结果==\n");
            		printf("正序:");
            		PrintPolyn(Pa);
            		Reverse_Linklist(Pa);
            		printf("逆序:");
            		PrintPolyn(Pa);
            		DestroyPolyn(Pa);
            		
            		break;
            		
            	case 2://减法 
            		
            		printf("请输入多项式A的项数: ");
            		scanf("%d", &m); 
            		printf("请输入%d对系数指数:\n ",m);
            		CreatPolyn(Pa, m);
            		PrintPolyn(Pa); 
            		
            		printf("请输入多项式B的项数: ");
            		scanf("%d", &m); 
            		printf("请输入%d对系数指数:\n ",m);
            		CreatPolyn(Pb, m);
            		PrintPolyn(Pb);
            		
            		SubtractPolyn(Pa, Pb);
            		printf("==运算结果==\n");
            		printf("正序:");
            		PrintPolyn(Pa);
            		Reverse_Linklist(Pa);
            		printf("逆序:");
            		PrintPolyn(Pa);
            		DestroyPolyn(Pa);
            		
            		break;
            		
            	case 3://乘法 
            		
            		printf("请输入多项式A的项数: ");
            		scanf("%d", &m); 
            		printf("请输入%d对系数指数:\n ",m);
            		CreatPolyn(Pa, m);
            		PrintPolyn(Pa); 
            		
            		printf("请输入多项式B的项数: ");
            		scanf("%d", &m); 
            		printf("请输入%d对系数指数:\n ",m);
            		CreatPolyn(Pb, m);
            		PrintPolyn(Pb);
            		
            		MultiplyPolyn(Pa, Pb);
            		printf("==运算结果==\n");
            		printf("正序:");
            		PrintPolyn(Pa);
            		Reverse_Linklist(Pa);
            		printf("逆序:");
            		PrintPolyn(Pa);
            		DestroyPolyn(Pa);
            		
            		break;
                case 0:
                    return 0;
                   break;
                default:
                    printf("输入错误,请重新输入\n");
            }
        }
    }
        		
            		printf("请输入多项式B的项数: ");
            		scanf("%d", &m); 
            		printf("请输入%d对系数指数:\n ",m);
            		CreatPolyn(Pb, m);
            		PrintPolyn(Pb);
            		
            		MultiplyPolyn(Pa, Pb);
            		printf("==运算结果==\n");
            		printf("正序:");
            		PrintPolyn(Pa);
            		Reverse_Linklist(Pa);
            		printf("逆序:");
            		PrintPolyn(Pa);
            		DestroyPolyn(Pa);
            		
            		break;
                case 0:
                    return 0;
                   break;
                default:
                    printf("输入错误,请重新输入\n");
            }
        }
    }
    
    展开全文
  • 基于线性表的一元多项式计算-数据结构设计报告,欢迎大家试用。
  • 学 院 课 程 设 计 说 明 书 题 目 一元多项式计算问题 系 ( 部 ) 计算机科学与技术系 专 业 ( 班 级 ) 计算机科学与技术专业 姓 名 学 号 指 导 教 师 起 止 日 期 第十三十四周 . . 课程设计任务书 课程名称数据...
  • 一元多项式计算 程序所能达到的功能: 1.实现一元多项式的输入; 2.实现一元多项式的输出; 3.计算两个一元多项式的和并输出结果; 4.计算两个一元多项式的差并输出结果; 效果图 #include<stdio.h> #include<...

    一元多项式计算
    程序所能达到的功能:
    1.实现一元多项式的输入;
    2.实现一元多项式的输出;
    3.计算两个一元多项式的和并输出结果;
    4.计算两个一元多项式的差并输出结果;

    效果图
    在这里插入图片描述

    #include<stdio.h>
    #include<malloc.h> //头文件 
    typedef struct Polynomial{   //定义一个指针类型Polynomial 
              float coef;  //系数 
              int expn;    //指数 
              struct Polynomial *next;
    } *Polyn, Polynomial; //Polyn 为结点指针类型
    void Insert(Polyn p, Polyn h) {
           if(p->coef==0) free(p) ; //系数为 0 的话释放结点
           else{
                  Polyn q1, q2;
                  q1=h; q2=h->next;   //h是头指针,q1指向头指针,q2指向头指针的下一位 
            while(q2&&p->expn<q2->expn) { //查找插入位置
                  q1=q2;
                  q2=q2->next;
                }
           if(q2&&p->expn==q2->expn) { //将指数相同的项合并
                  q2->coef+=p->coef;
                  free(p) ;  //释放结点 
           if(!q2->coef) { //系数为 0 的话释放结点
                  q1->next=q2->next;
                  free(q2) ;   //释放指针q2 
                }
            }
        else{ //指数为新时将结点插入
               p->next=q2;
               q1->next=p;
            }
        }
    } //Insert
      Polyn CreatePolyn(Polyn head, int m) {//建立一个头指针为 head、 项数为 m 的一元多项式
              int i;
              Polyn p; //p是指针 
              p=head=(Polyn) malloc(sizeof(struct Polynomial) ) ;
              head->next=NULL;
              for(i=0; i<m; i++) {
              p=(Polyn) malloc(sizeof(struct Polynomial) ) ; //建立新结点以接收数据
              printf("请输入第%d 项的系数与指数: ", i+1) ;
              scanf("%f %d", &p->coef, &p->expn) ; //中间用空格隔开 
              Insert(p, head) ; //调用 Insert 函数插入结点
            }
            return head;
    } //CreatePolyn
    void DestroyPolyn(Polyn p) {//销毁多项式 p
              Polyn q1, q2;
              q1=p->next;  //q1指向指针p的下一位 
              q2=q1->next;  //q2指向指针q1的下一位 
              while(q1->next) {
              free(q1) ;  //释放指针q1 
              q1=q2; //指针后移
              q2=q2->next;
              }
            }
    void PrintPolyn(Polyn P) {
              Polyn q=P->next;
              int flag=1; //项数计数器
              if(!q) { //若多项式为空, 输出 0
              putchar(' 0' ) ;
              printf("\n") ;
              return;
           }
    while (q) {
              if(q->coef>0&&flag!=1) putchar(' +' ) ; //系数大于 0 且不是第一项
              if(q->coef!=1&&q->coef!=-1) {//系数非 1 或-1 的普通情况
              printf("%g", q->coef) ;
              if(q->expn==1) putchar(' X' ) ;
              else if(q->expn) printf("X^%d", q->expn) ;
            }
         else{
            if(q->coef==1) {
            if(!q->expn) putchar(' 1' ) ;
            else if(q->expn==1) putchar(' X' ) ;
            else printf("X^%d", q->expn) ;
            }
          if(q->coef==-1) {
               if(!q->expn) printf("-1") ;
               else if(q->expn==1) printf("-X") ;
               else printf("-X^%d", q->expn) ;
                }
            }
        q=q->next;
        flag++;
        } //while
          printf("\n") ;
    } //PrintPolyn
    int compare(Polyn a, Polyn b) {
            if(a&&b) {
            if(!b|| a->expn>b->expn) return 1;
             else if(!a|| a->expn<b->expn) return -1;
            else return 0;
    }
            else if(!a&&b) return -1; //a 多项式已空, 但 b 多项式非空
            else return 1; //b 多项式已空, 但 a 多项式非空
    } //compare
    Polyn AddPolyn(Polyn pa, Polyn pb) {//求解并建立多项式 a+b, 返回其头指针
            Polyn qa=pa->next;
            Polyn qb=pb->next;
            Polyn headc, hc, qc;
            hc=(Polyn) malloc(sizeof(struct Polynomial) ) ; //建立头结点
            hc->next=NULL;
            headc=hc;
            while(qa|| qb) {
            qc=(Polyn) malloc(sizeof(struct Polynomial) ) ;
            switch(compare(qa, qb) ) {
            case 1:
            {
              qc->coef=qa->coef;
               qc->expn=qa->expn;
              qa=qa->next;
               break;
            }
            case 0:
            {
               qc->coef=qa->coef+qb->coef;
               qc->expn=qa->expn;
                qa=qa->next;
                qb=qb->next;
               break;
            }
            case -1:
            {
                qc->coef=qb->coef;
                qc->expn=qb->expn;
                qb=qb->next;
                break;
            }
        } //switch
    if(qc->coef!=0) {
                qc->next=hc->next;
                 hc->next=qc;
                hc=qc;
            }
              else free(qc) ; //当相加系数为 0 时, 释放该结点
        } //while
           return headc;
    } //AddPolyn
    Polyn SubtractPolyn(Polyn pa, Polyn pb) {//求解并建立多项式 a+b, 返回其头指针
                Polyn h=pb;
                Polyn p=pb->next;
                Polyn pd;
                while(p) { //将 pb 的系数取反
                p->coef*=-1;
                p=p->next;
           }
              pd=AddPolyn(pa, h) ;
              for(p=h->next; p; p=p->next) //恢复 pb 的系数
              p->coef*=-1;
              return pd;
    } //SubtractPolyn
    int main() {
               int m, n, flag=0;
               float x;
                Polyn pa=0, pb=0, pc, pd, pe, pf; //定义各式的头指针, pa 与 pb 在使用前付初值 NULL
               printf("** 欢 迎 您 的 使 用**\n") ;
               printf("请输入多项式 a 的项数: ") ;
                scanf("%d", &m) ;
               pa=CreatePolyn(pa, m) ; //建立多项式 a
               printf("**\n") ;
               printf("请输入多项式 b 的项数: ") ;
               scanf("%d", &n) ;
               pb=CreatePolyn(pb, n) ; //建立多项式 b
    //输出菜单
                printf("**\n") ;
                printf("功能项: \n\t1. 输出多项式 a 和 b\n\t2. 建立多项式 a+b\n\t3. 建立多项式a-b\n") ;
                printf("\t4. 退 出 \n** 请 输 入 功 能 项 编 号\n") ;
                for(; ; flag=0) {
                printf("执行操作: ") ;
                scanf("%d", &flag) ;
                if(flag==1) {
                printf("多项式 a: ") ; PrintPolyn(pa) ;
                printf("多项式 b: ") ; PrintPolyn(pb) ; printf("请输入功能项编号\n") ;continue;
            }
              if(flag==2) {
               pc=AddPolyn(pa, pb) ;
               printf("多项式 a+b: ") ; PrintPolyn(pc) ;
                DestroyPolyn(pc) ; printf("请 输 入 功 能 项 编 号\n") ; continue;
        }
               if(flag==3) {
               pd=SubtractPolyn(pa, pb) ;
                printf("多项式 a-b: ") ; PrintPolyn(pd) ;
                DestroyPolyn(pd) ; printf("请 输 入 功 能 项 编 号\n") ; continue;
           }
                if(flag==4) break;
                if(flag<1|| flag>4) printf("Error!!!\n") ; continue;
    } //for
                DestroyPolyn(pa) ;
                DestroyPolyn(pb) ;
                return 0;
    }
    
    展开全文
  • 数据结构课程设计一元多项式计算,实验代码和实验报告
  • 数据结构设计报告一元多项式计算,加深对数据结构的理解和编程能力
  • 数据结构,课程设计,c语言,一元多项式计算。顺序结构、动态链表结构下的一元多项式的加法、减法、乘法的实现。 设有一元多项式Am(x)和Bn(x). Am(x)=A0+A1x1+A2x2+A3x3+… +Amxm Bn(x)=B0+B1x1+B2x2+B3x3+… +...
  • 一元多项式计算.zip

    2021-06-17 19:21:31
    学习
  • 本人以及班上两位高手精心写的地图着色与一元多项式计算的实验报告,可谓风格各异,有偏可视化的,有偏文件应用的…… 需求分析,详细设计,用户手册一应俱全,欢迎大家参考,并提出宝贵意见……
  • 一元多项式计算 任务:能够按照指数降序排列建立并输出多项式;能够完成两个多项式的相加、相减和相乘,并将结果输出; 在上交资料中请写明:存储结构、多项式相加的基本过程的算法(可以使用程序流程图)、源程序、...

    一元多项式计算
    任务:能够按照指数降序排列建立并输出多项式;能够完成两个多项式的相加、相减和相乘,并将结果输出;
    在上交资料中请写明:存储结构、多项式相加的基本过程的算法(可以使用程序流程图)、源程序、测试数据和结果、算法的时间复杂度、另外可以提出算法的改进方法;
    设有一元多项式Am(x)和Bn(x).
    Am(x)=A0+A1x1+A2x2+A3x3+… +Amxm
    Bn(x)=B0+B1x1+B2x2+B3x3+… +Bnxn
    请实现求M(x)=Am(x)+Bn(x),M(x)=Am(x)-Bn(x)和M(x)=Am(x)×Bn(x)。
    要求:

    1. 首先判定多项式是否稀疏(个人判定以系数为0的项数大于项的最大次数加+1除2)
    2. 分别采用顺序和动态存储结构实现;
    3. 结果M(x)中无重复阶项和无零系数项;
    4. 要求输出结果的升幂和降幂两种排列情况
    
    #include <bits/stdc++.h>
    using namespace std;
    struct A//定义双向链表,方便降幂输出
    {
        int a;
        int b;
        struct A*prior;
        struct A*next;
    };
    void paixu(struct A* head,struct A*p)//链表幂从小到大排序,进来一个排一个
    {
        struct A*p1,*p2;
        int flag=0;
        if(head->next==NULL)
        {
            p->next=head->next;
            head->next=p;
        }
        else
        {
            p1=head;
            p2=head->next;
            while(p2!=NULL)
            {
                if(p->b<p2->b)
                {
                    p1->next=p;
                    p->next=p2;
                    flag=1;
                    break;
                }
                else if(p->b==p2->b)
                {
                    p2->a+=p->a;
                    flag=1;
                    break;
                }
                else
                {
                    p1=p2;
                    p2=p2->next;
                }
    
            }
            if(flag==0)
            {
                p1->next=p;
                p->next=NULL;
            }
        }
    }
    void jia1(struct A*head1,struct A*head2,struct A*head3)//链表相加
    {
        struct A*p1,*p2,*p3,*p;
        p1=head1->next;
        p2=head2->next;
        p3=head3;//有意思
        head3->next=NULL;//避免运行加减函数互相影响
        while(p1!=NULL&&p2!=NULL)
        {
    
            p=(struct A*)malloc(sizeof(struct A));
            p->next=NULL;
            if(p1->b==p2->b)
            {
                if(p1->a+p2->a!=0)//链表相加为0,直接不录入
                {
                    p->a=p1->a+p2->a;
                    p->b=p1->b;
                    p3->next=p;
                    p3=p;
                }
                p1=p1->next;
                p2=p2->next;
            }
            else if(p1->b<p2->b)
            {
                p->a=p1->a;
                p->b=p1->b;
                p3->next=p;
                p3=p;
    
                p1=p1->next;
    
            }
            else
            {
                p->a=p2->a;
                p->b=p2->b;
                p3->next=p;
                p3=p;
    
                p2=p2->next;
            }
        }
    
        if(p1==NULL)
        {
            while(p2!=NULL)
            {
                p=(struct A*)malloc(sizeof(struct A));
                p->next=NULL;
                p->a=p2->a;
                p->b=p2->b;
                p3->next=p;
                p3=p;
                p2=p2->next;
            }
        }
        else
        {
            while(p1!=NULL)
            {
                p=(struct A*)malloc(sizeof(struct A));
                p->next=NULL;
                p->a=p1->a;
                p->b=p1->b;
                p3->next=p;
                p3=p;
                p1=p1->next;
            }
        }
    }
    void jian1(struct A*head1,struct A*head2,struct A*head3)//链表相减,只需在加的基础上改+为-
    {
        struct A*p1,*p2,*p3,*p;
        p1=head1->next;
        p2=head2->next;
        p3=head3;//有意思
         head3->next=NULL;//重要
        while(p1!=NULL&&p2!=NULL)
        {
    
            p=(struct A*)malloc(sizeof(struct A));
            p->next=NULL;
            if(p1->b==p2->b)
            {
                if(p1->a-p2->a!=0)
                {
                    p->a=p1->a-p2->a;
                    p->b=p1->b;
                    p3->next=p;
                    p3=p;
                }
                p1=p1->next;
                p2=p2->next;
            }
            else if(p1->b<p2->b)
            {
                p->a=-p1->a;
                p->b=p1->b;
                p3->next=p;
                p3=p;
    
                p1=p1->next;
    
            }
            else
            {
                p->a=-p2->a;
                p->b=p2->b;
                p3->next=p;
                p3=p;
    
                p2=p2->next;
            }
        }
    
        if(p1==NULL)
        {
            while(p2!=NULL)
            {
                p=(struct A*)malloc(sizeof(struct A));
                p->next=NULL;
                p->a=-p2->a;
                p->b=p2->b;
                p3->next=p;
                p3=p;
                p2=p2->next;
            }
        }
        else
        {
            while(p1!=NULL)
            {
                p=(struct A*)malloc(sizeof(struct A));
                p->next=NULL;
                p->a=-p1->a;
                p->b=p1->b;
                p3->next=p;
                p3=p;
                p1=p1->next;
            }
        }
    }
    
    int chen1(struct A*head1,struct A*head2,struct A*head3,struct A*head4,struct A*head5)//链表相乘,化为相加
    {
        struct A*p1,*p2,*p3,*p4,*p5,*p;
        int i=1;
        p1=head1->next;
        while(p1!=NULL)
        {
    
            p2=head2->next;
            p5=head5->next;
            while(p2!=NULL)
            {
                p5->a=p1->a*p2->a;
                p5->b=p1->b+p2->b;
                p5=p5->next;
                p2=p2->next;
            }
            //head4,head3作为容器,进行连加,好像可以不用
            if(i==1)
            {
                jia1(head5,head4,head3);
                i=2;//标志
            }
            else
            {
                jia1(head5,head3,head4);
                i=1;//标志
            }
            p1=p1->next;
    
        }
    
        return i;//判断最后的容器是head3,还是head4;
    }
    void xishu(int a[],int max)//顺序存储判断稀疏
    {
        int min=0;
       for(int i=0;i<=max;i++)
       {
           if(a[i]==0)
            min++;
       }
       if(min>(max+1)/2)
       cout<<"表达式稀疏"<<endl;
       else
       cout<<"表达式正常"<<endl;
    }
    void xishu1(struct A*head)//链式存储判断稀疏
    {
        struct A*p;int i=0,max=0;
        p=head->next;
        while(p!=NULL)
        {   i++;
           if(max<p->b)
            max=p->b;
            p=p->next;
        }
        if(i<=(max+1)/2)
        cout<<"表达式稀疏"<<endl;
        else
         cout<<"表达式正常"<<endl;
    }
    void jia(int a[],int b[],int c[],int maxa,int maxb,int &maxc,int &flag)//顺序存储相加
    {
        maxc=maxa>maxb?maxa:maxb;
        cout<<"顺序:";
        for(int i=0;i<=maxc;i++)//注意maxc包含在内
        {
            c[i]=a[i]+b[i];
            if(c[i]!=0)
             {cout<<c[i]<<"*x^"<<i<<" ";
              flag=1;}
        }
        if(flag==0)
          cout<<"0";
          cout<<endl;
          cout<<"逆序:";
           for(int i=maxc;i>=0;i--)//注意maxc包含在内
        {
            if(c[i]!=0)
             {cout<<c[i]<<"*x^"<<i<<" ";
              flag=1;}
        }
    
    }
    void jian(int a[],int b[],int c[],int maxa,int maxb,int &maxc,int &flag)//顺序存储相减
    {
      maxc=maxa>maxb?maxa:maxb;
      cout<<"顺序:";
        for(int i=0;i<=maxc;i++)//注意maxc包含在内
        {
            c[i]=a[i]-b[i];
            if(c[i]!=0)
            {cout<<c[i]<<"*x^"<<i<<" ";
              flag=1;}
        }
         if(flag==0)
          cout<<"0";
          cout<<endl;
           cout<<"逆序:";
           for(int i=maxc;i>=0;i--)//注意maxc包含在内
        {
            if(c[i]!=0)
             {cout<<c[i]<<"*x^"<<i<<" ";
              flag=1;}
        }
    }
    void chen(int a[],int b[],int c[],int maxa,int maxb,int &maxc,int &flag)//顺序存储相乘
    {
        for(int i=0;i<=maxa;i++)
        for(int j=0;j<=maxb;j++)
        {
            if(a[i]!=0&&b[j]!=0)
            {
                c[i+j]+=a[i]*b[j];
            }
        }
        cout<<"顺序:";
        for(int i=0;i<=maxa+maxb;i++)
        {
            if(c[i]!=0)
            {
                cout<<c[i]<<"*x^"<<i<<" ";
                flag=1;
            }
        }
        if(flag==0)
        cout<<"0";
        cout<<endl;
        cout<<"逆序:";
        for(int i=maxa+maxb;i>=0;i--)
        {
            if(c[i]!=0)
            {
                cout<<c[i]<<"*x^"<<i<<" ";
                flag=1;
            }
        }
    
    }
    int main()
    {
        int n1,n2,e,f,maxa,maxb,maxc,sum,sum1,flag;
        int a[100],b[100],c[100];
        memset(a,0,sizeof(a));
        memset(b,0,sizeof(b));
        memset(c,0,sizeof(c));
        maxa=maxb=maxc=0;
        char d;
        cout<<"请输入数字,数字1表示进行顺序存储,数字2表示进行动态存储"<<endl;
        cin>>sum;
        while(sum!=1&&sum!=2)
        {
            cout<<"输入错误,请输入数字,数字1表示进行顺序存储,数字2表示进行动态存储"<<endl;
            cin>>sum;
        }
        cout<<"输入成功"<<endl;
        if(sum==2)
        {
            struct A *head1,*head2,*p,*head3,*head4,*head5,*p1,*p2,*p3;
            head1=(struct A*)malloc(sizeof(struct A));
            head2=(struct A*)malloc(sizeof(struct A));
            head3=(struct A*)malloc(sizeof(struct A));
            head4=(struct A*)malloc(sizeof(struct A));
            head5=(struct A*)malloc(sizeof(struct A));
            head1->next=NULL;//有意思
            head2->next=NULL;
            head3->next=NULL;
            head4->next=NULL;
            head5->next=NULL;
    
            cout<<"请输入第一个表达式的项个数"<<endl;
            cin>>n1;
            while(n1<=0)
            {
                cout<<"请重新输入,输入值需大于0"<<endl;
                cin>>n1;
            }
             cout<<"输入成功"<<endl;
             cout<<"请输入第一个表达式,每个项的系数和指数以','分隔,项与项之间以空格或回车分隔"<<endl;
            for(int i=0; i<n1; i++)
            {
                cin>>e>>d>>f;
                p=(struct A*)malloc(sizeof(struct A));
                if(e!=0)
                {
                    p->a=e;
                    p->b=f;
                     paixu(head1,p);
                }
    
            }
            xishu1(head1);
            cout<<"请输入第二个表达式的项个数"<<endl;
            cin>>n2;
            while(n2<=0)
            {
                cout<<"请重新输入,输入值需大于0"<<endl;
                cin>>n2;
            }
             cout<<"输入成功"<<endl;
            cout<<"请输入第二个表达式,每个项的系数和指数以','分隔,项与项之间以空格或回车分隔"<<endl;
            p1=head5;
            for(int i=0; i<n2; i++)
            {
                cin>>e>>d>>f;
                p=(struct A*)malloc(sizeof(struct A));
                if(e!=0)
                {
                    p->a=e;
                    p->b=f;
                    p2=(struct A*)malloc(sizeof(struct A));
                    p2->next=NULL;
                    p1->next=p2;
                    p1=p2;
                    paixu(head2,p);
                }
    
            }
             xishu1(head2);
            cout<<"输入1表示相加,输入2表示相减,输入3表示相乘"<<endl;
            cin>>sum1;
            while(sum1!=1&&sum1!=2&&sum1!=3)
            {
                cout<<"输入错误,请重新输入"<<endl;
                cin>>sum1;
            }
                    cout<<"输入成功"<<endl;
            while(1)
            {
                flag=0;
            if(sum1==1)
            {
                jia1(head1,head2,head3);
                cout<<"顺序:";
                p=head3->next;
                p3=head3;
                while(p)
                {
                    cout<<p->a<<"*x^"<<p->b<<" ";
                    p->prior=p3;//顺便从后往前链接
                    p3=p;
                    p=p->next;
                    flag=1;
                }
                if(flag==0)
                cout<<"0";
                cout<<endl;
                cout<<"逆序:";
                while(p3!=head3)
                {
                    cout<<p3->a<<"*x^"<<p3->b<<" ";
                    p3=p3->prior;
                }
                if(flag==0)
                cout<<"0";
                cout<<endl;
            }
            if(sum1==2)
            {
    
                jian1(head1,head2,head3);
                cout<<"顺序:";
                p=head3->next;
                p3=head3;
                while(p)
                {
                    cout<<p->a<<"*x^"<<p->b<<" ";
                    p->prior=p3;//顺便从后往前链接
                    p3=p;
                    p=p->next;
                    flag=1;
                }
                if(flag==0)
                cout<<"0";
                cout<<endl;
                cout<<"逆序:";
                while(p3!=head3)
                {
                    cout<<p3->a<<"*x^"<<p3->b<<" ";
                    p3=p3->prior;
                }
                if(flag==0)
                cout<<"0";
                cout<<endl;
    
            }
            if(sum1==3)
            {
                if(chen1(head1,head2,head3,head4,head5)==2)
                    {p=head3->next;p3=head3;}
                else
                    {p=head4->next;p3=head4;}
    
                 cout<<"顺序:";
    
                while(p)
                {
                    cout<<p->a<<"*x^"<<p->b<<" ";
                    p->prior=p3;//顺便从后往前链接
                    p3=p;
                    p=p->next;
                    flag=1;
                }
                if(flag==0)
                cout<<"0";
                cout<<endl;
                cout<<"逆序:";
                if(chen1(head1,head2,head3,head4,head5)==2)
                while(p3!=head3)
                {
                    cout<<p3->a<<"*x^"<<p3->b<<" ";
                    p3=p3->prior;
                }
                else
                 while(p3!=head4)
                {
                    cout<<p3->a<<"*x^"<<p3->b<<" ";
                    p3=p3->prior;
                }
                if(flag==0)
                cout<<"0";
                cout<<endl;
    
            }
           cout<<"输入1表示相加,输入2表示相减,输入3表示相乘,输入0结束"<<endl;
           cin>>sum1;
           while(sum1!=1&&sum1!=2&&sum1!=3&&sum1!=0)
           {
               cout<<"输入错误,请重新输入";
               cin>>sum1;
           }
          if(sum1==0)
           {
               cout<<"结束";
               break;
           }
    
        }
    }
    else
    {
        cout<<"请输入第一个表达式的项个数"<<endl;
            cin>>n1;
            while(n1<=0)
            {
                cout<<"请重新输入,输入值需大于0"<<endl;
                cin>>n1;
            }
             cout<<"输入成功"<<endl;
             cout<<"请输入第一个表达式,每个项的系数和指数以','分隔,项与项之间以空格或回车分隔"<<endl;
        for(int i=0;i<n1;i++)
        {
            cin>>e>>d>>f;
            a[f]+=e;
            if(maxa<f)
            maxa=f;
    
        }
          xishu(a,maxa);
          cout<<"请输入第二个表达式的项个数"<<endl;
            cin>>n2;
            while(n2<=0)
            {
                cout<<"请重新输入,输入值需大于0"<<endl;
                cin>>n2;
            }
             cout<<"输入成功"<<endl;
            cout<<"请输入第二个表达式,每个项的系数和指数以','分隔,项与项之间以空格或回车分隔"<<endl;
        for(int i=0;i<n2;i++)
        {
            cin>>e>>d>>f;
            b[f]+=e;
            if(maxb<f)//检查相同的话
            maxb=f;
    
        }
         xishu(b,maxb);
           cout<<"输入1表示相加,输入2表示相减,输入3表示相乘"<<endl;
            cin>>sum1;
            while(sum1!=1&&sum1!=2&&sum1!=3)
            {
                cout<<"输入错误,请重新输入"<<endl;
                cin>>sum1;
            }
             cout<<"输入成功"<<endl;
             while(1)
             {   flag=0;
                  if(sum1==1)
            {
              jia(a,b,c,maxa,maxb,maxc,flag);
              if(flag==0)
              cout<<"0";
              cout<<endl;
            }
            if(sum1==2)
            {
                jian(a,b,c,maxa,maxb,maxc,flag);
                 if(flag==0)
              cout<<"0";
              cout<<endl;
            }
            if(sum1==3)
            {
               chen(a,b,c,maxa,maxb,maxc,flag);
             if(flag==0)
             cout<<"0";
              cout<<endl;
            }
             memset(c,0,sizeof(c));
             cout<<"输入1表示相加,输入2表示相减,输入3表示相乘,输入0结束"<<endl;
           cin>>sum1;
           while(sum1!=1&&sum1!=2&&sum1!=3&&sum1!=0)
           {
               cout<<"输入错误,请重新输入";
               cin>>sum1;
           }
           if(sum1==0)
           {
               cout<<"结束";
               break;
           }
    
             }
    
    }
    }
    
    
    展开全文
  • 要求能够按照指数降序排列建立并输出一元多项式;能够完成两个一元多项式的相加、相减,并将结果输入。
  • 一元多项式计算 一、主要功能 (1) 能够按照指数降序排列建立并输出多项式; (2) 能够完成一元多项式的相加、相减,并将结果输出。 二、算法思想 根据一元多项式相加(减)的运算规则: (1) 对于两个一元...

    一、主要功能

          (1) 能够按照指数降序排列建立并输出多项式;

          (2) 能够完成一元多项式的相加相减,并将结果输出。

    二、算法思想

          根据一元多项式相加(减)的运算规则:

          (1) 对于两个一元多项式中所有指数相同的项,对应指数相加(减)。若和(差)不为零,则构成“和(差)多项式”中的一项;

          (2) 对于两个一元多项式中所有指数不相同的项, 则分别写到 “和(差)多项式”中去。

          因为多项式指数最高项以及项数是不确定的,因此采用线性链表的存储结构便于实现一元多项式的运算。为了节省空间,设计采用两个链表分别存放多项式A和多项式B。对于最后计算所得的多项式则利用多项式a进行存储。设计利用了多项式单链表的插入和删除操作。假设指针 qa 和 qb 分别指向多项式 A 和多项式 B 中当前进行比较的某个节点。

    (1)一元多项式加法运算

            它从两个多项式的头部开始, 两个多项式的某一项都不为空时:

            (1)  如果指数相等的话,则系数就应该相加,若其和不为零的话,则使用头插法建立一个新的节点;

            (2)  qa 的指数小于 qb 的指数的话就应该复制 qb 的节点到多项式中;

            (3)  qa 的指数大于 qb 的指数的话, 就应该复制 qa 节点到多项式中。当第二个多项式为空,第一个多项式不为空时,将第一个多项式用新节点产生。当第一个多项式为空, 第二个多项式不为空时,将第二个多项式用新节点产生。

    (2)一元多项式减法运算

           它从两个多项式的头部开始,两个多项式的某一项都不为空时:

           (1)  如果指数相等的话,系数就相减;相加的和不为零的话,用头插法建立一个新的节点;

           (2)  qa 的指数小于 qb 的指数的话,就应该复制qb的节点到多项式中;

           (3)  qa 的指数大于 qb 的指数的话就应该复制 qa 的节点到多项式中,并且建立的节点的系数为原来的相反数;当第二个多项式空,第一个多项式不 为空时,将第一个多项式用新节点产生。当第一个多项式空,第二个多项式不为空时,将第二个多项式用新节点产生,并且建立的节点的系数为原来的相反数。

    三、抽象数据类型Polyn的实现

    //输入m项的系数和指数,建立一元多项式p
    void CreatePolyn(&P, m);
    
    //销毁一元多项式p
    void Destroypolyn(&P);
    
    //打印输出一元多项式p
    void PrintPolyn(P);
    
    //返回一元多项式P的项数
    int PolynLength(P);
    
    //完成多项式的相加Pa=Pa+Pb
    void AddPolyn(&Pa, &Pb);
    
    //完成多项式的相减Pa=Pa-Pb
    void SubstractPolyn(&pa, &pb);
    
    //完成多项式相乘运算
    void Multiplypolyn(&Pa, &Pa);

     

     


     

    展开全文
  • 孝感学院计算机科学系 11 级 课程设计课程设计报告 题目 多项式求导 班级 1017142 学号 101714201 姓名 指导教师 李志敏 2012 年 2 月 12 日 1 目录 1 需求分析 3 1.1 功能需求分析 3 1.2 设计平台 3 2 概要设计 3 ...
  • 一元多项式计算(链表)

    千次阅读 2019-04-15 20:55:07
    /案例1:一元多项式计算 P(x)=10+5x-4x2+3x3+2x^4 [分析]下标表示指数,数据域贮存系数/ #include<stdio.h> #include<iostream.h>//流 #include<malloc.h> #include<cstdlib>//包含...
  • 用C++完成一元稀疏多项式的加、减、乘、求导、求值运算 功能很强大
  • 任务:能够按照指数降序排列建立并输出多项式; 能够完成两个多项式的相加、相减,并将结果输入; 在上交资料中请写明:存储结构、多项式相加的基本过程的算法(可以使用程序流程图) 、源程序、测试数据和结果、...
  • 该程序实现一元多项式的输入,递增排序,合并,赋值计算
  • 适合毕业设计的同学用,课程设计做的,老师检查过关,绝对能用,都来下吧
  • 本代码用的是迭代器将算法对立与数据结构,运用了分层结构的思想。
  • 数据结构课程设计 运动会分数统计,一元多项式计算,订票系统, 迷宫求解, 文章编辑 joseph环 猴子选大王 建立二叉树,层序、先序遍历( 用递归或非递归的方法都可以>
  • 并较完善的一元多项式计算代码,能够实现一元多项式的加减运算!并且正确输出结果!

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 6,032
精华内容 2,412
关键字:

一元多项式计算