单链表-稀疏多项式的表示

最新推荐文章于 2024-11-30 10:02:55 发布

原创最新推荐文章于 2024-11-30 10:02:55 发布 · 1.6k 阅读

11 ·

CC 4.0 BY-SA版权

文章标签：

#数据结构

数据结构专栏收录该内容

53 篇文章

订阅专栏

本文介绍了一种稀疏多项式的表示方法及其在计算机科学中的应用，通过定义小项和多项式的数学模型，使用链表数据结构来实现多项式的创建、插入、输出、销毁以及加法、减法、乘法、除法和求导等基本运算。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

稀疏多项式：如P(x)=1+3x1000+x20000； Q(x)=x+x50000

R(x)=1+x+3x1000+x20000+x50000。

数学模型:

P=((1,0),(3,1000),(1,20000)) Q=((1,1),(1,50000)) R=((1,0),(1,1),(3,1000),(1,20000),(1,50000))

一个基础元素称为一个小项，可定义类型Term

      typedef struct{ 
	  float coef;int expn;
      }Term;

一个多项式实际可看做元素类型为term的线性结构的数据对象，可在线性表的基础上实现具体操作。

首先定义辅助宏：

#define OK 1
#define LIST_INIT_SIZE 100
#define LISTINCREMENT 10
#define ERROR 0
#define TRUE 1
#define FALSE 0
#define NULL 0
#define OVERFLOW -1
typedef int Status;

多项式的存储结构定义：

//多项式的存储结构定义
typedef struct{
    float coef; //系数
    int expn;  //指数
}term,ElemType;
typedef struct LNode{
    ElemType data;
    struct LNode *next;
}*LinkList;
typedef LinkList Polynomial;

插入一个结点，使之按照指数大小从大到小排序。

Status Insert(Polynomial &P,Polynomial &q){
	//插入一个结点
    if(q->data.coef==0)
        return OK;
    LNode *prep,*p;
    prep=P;
    p=P->next;
    while(p&&p->data.expn>q->data.expn){ //有序插入
        prep=p;
        p=p->next;
    }
    if(!p) //没找到插入队尾
        prep->next=q;
    else{
       if(p->data.expn==q->data.expn) { //指数相等
           if(p->data.coef==q->data.coef*(-1)){ //系数和为0则销毁
               prep->next=p->next;
               free(p);
           }
            else  //否则系数改变
               p->data.coef+=q->data.coef;
       }
       else{   //指数不相等，插入这一项
            prep->next=q;
            q->next=p;
        }
    }
    return OK;
}

输入n项指数与系数，创建一元多项式.

Status InputElem(ElemType &e){
    //输入一个项
    scanf("%f %d",&e.coef,&e.expn);
    return OK;
}
Status CreatePolyn(Polynomial &P,int n){
    //输入n项指数与系数，创建一元多项式
    printf("请输入多项式的项数: ");
    scanf("%d",&n);
    if(n<0) 
        return ERROR;
    LNode *p;
    P=(LNode *)malloc(sizeof(LNode));
    if(!P)  //创建失败
        exit(OVERFLOW);
    P->next=NULL;
    for(int i=0;i<n;i++){
        p=(LNode *)malloc(sizeof(LNode));
	p->next=NULL;
	if(!p)
            exit(OVERFLOW);
	printf("请输入第 %d 项的系数与指数 ：",i+1);
        InputElem(p->data);
        Insert(P,p); //插入这个项,要求幂递增，乘法等也可用
    }
}

输出多项式.

Status  PrintPolyn(Polynomial &P){
    //输出多项式
    if(!P->next)
       printf("空多项式\n");
    else{
       LNode *p=P->next;
       while(p){
           if(p->data.coef>0&&p!=P->next)
                printf("+");
           if(p->data.coef==-1&&p->data.expn!=0)
                printf("-");
           if(p->data.coef!=1&&p->data.coef!=-1)
                printf("%.f",p->data.coef);
           else if((p->data.coef==1||p->data.coef==-1)&&p->data.expn==0)
                printf("%.f",p->data.coef);
           if(p->data.expn!=0)
                printf("x");
           if(p->data.expn!=1&&p->data.expn!=0)
                printf("^%d",p->data.expn);
           p=p->next;
	   }
           printf("\n");
       }
    return OK;
}

销毁一元多项式.

Status DestroyPolyn(Polynomial &P){
    //销毁一元多项式
    LNode *p=P,*q;
    while(p){
        q=p->next;
	free(p);
	p=NULL;
	p=q;
    }
    return OK;
}

计算Pa=Pa+Pb 并销毁Pb。

Status AddPolyn(Polynomial &Pa,Polynomial &Pb){
    //计算Pa=Pa+Pb 并销毁Pb。
    //如果pa指数等于pb的指数 一种情况两者系数和为0，此时
    //销毁pa项并且释放pb当前项。反之pa系数加上pb的系数并且释放pb当前项
    LNode *pa=Pa->next,*pb=Pb->next;
    LNode *prea=Pa,*preb=Pb;
    while(pa&&pb) { //用两个指针遍历整个链表
       if(pa->data.expn==pb->data.expn){
           if(pa->data.coef==pb->data.coef*(-1)){

           prea->next=pa->next;
           free(pa);
           pa=prea->next;
           preb->next=pb->next;
           free(pb);
           pb=preb->next;
	   }
           else{
               pa->data.coef+=pb->data.coef;
               prea=pa;
               pa=pa->next;
               preb->next=pb->next;
               free(pb);
               pb=preb->next;
	   }
       }
       else if(pa->data.expn<pb->data.expn){  //如果pa指数小，将pb这个结点插入pa前面 并且释放pb当前项
            preb->next=pb->next;
            pb->next=pa;
            prea->next=pb;
            pb=preb->next;
       }
       else { // 比较当前两项 如果pa指数大 pa后移一位
            prea=pa;
            pa=pa->next;
        }
    }
    if(pb) 
        prea->next=pb;
    free(Pb);
    Pb = NULL;
    return OK;
}

计算Pa=Pa-Pb 并销毁Pb。

Status DecreasePolyn(Polynomial &Pa,Polynomial &Pb){
//计算Pa=Pa-Pb 并销毁Pb。
    LNode *pa=Pa->next,*pb=Pb->next,*q;
    LNode *prea=Pa,*preb=Pb;
    while(pa&&pb){//用两个指针遍历整个链表
        if(pa->data.expn==pb->data.expn){//如果pa指数等于pb的指数 一种情况两者系数相等，此时销毁pa项并且释放pb当前项。反之pa系数加上pb的系数并且释放pb当前项
             if(pa->data.coef==pb->data.coef) {
                 prea->next=pa->next;
                 free(pa);
                 pa=prea->next;
                 preb->next=pb->next;
                 free(pb);
                 pb=preb->next;
			 }
             else{
                  pa->data.coef-=pb->data.coef;
                  prea=pa;
                  pa=pa->next;
                  preb->next=pb->next;
                  free(pb);
                  pb=preb->next;
			 }
		}
        else if(pa->data.expn<pb->data.expn){//如果pa指数小，将pb这个结点插入pa前面 并且释放pb当前项
             pb->data.coef*=(-1);
             preb->next=pb->next;
             pb->next=pa;
             prea->next=pb;
              pb=preb->next;
		}
        else{//比较当前两项 如果pa指数大 pa后移一位
             prea=pa;
             pa=pa->next;
		}
	}
    q=pb;
    while(pb){
        pb->data.coef*=(-1);
        pb=pb->next;
	}
    if(q)
	    prea->next=q;
    free(Pb);
    return OK;
}

计算Pc=Pa*Pb 。

Status RidePolyn(Polynomial &Pa,Polynomial &Pb,Polynomial &Pc){
//计算Pc=Pa*Pb 。
    Pc=(LNode *)malloc(sizeof(LNode));
    if(!Pc) 
         exit(OVERFLOW);
    Pc->next=NULL;
    LNode *pa=Pa->next,*pb=Pb->next,*p;    //设两个指针遍历Pa Pb
    while(pa) { //循环Pa与Pb 将每一项相乘，得到一个新的结点插入Pc中
       while(pb) {
           p=(LNode *)malloc(sizeof(LNode)); //设立一个新结点
           p->next=NULL;
           if(!p)
               exit(OVERFLOW);
            p->data.coef=pa->data.coef*pb->data.coef;
            p->data.expn=pa->data.expn+pb->data.expn;
            Insert(Pc,p);//插入新结点
           pb=pb->next;
       }
       pa=pa->next;
       pb=Pb->next;
    }
    return OK;
}

计算Pc=Pa/Pb 。商存入Pc，余数存入Pa.

Status RemovePolyn(Polynomial &Pa,Polynomial &Pb,Polynomial &Pc){
    //计算Pc=Pa/Pb 。商存入Pc，余数存入Pa
    //算法思路：首先整除一下，然后计算得到的余数，然后再用余数除Pb，
    //不断循环直到余数的首项指数小于Pb的首项指数为止，即余数为0
    Polynomial P; //设立一个临时多项式
    Pc=(LNode *)malloc(sizeof(LNode));
    if(!Pc)
      	 exit(OVERFLOW);
    Pc->next=NULL;
    float a;
    int b;
    LNode *pa=Pa->next,*pb=Pb->next,*p,*q;
    while(pa&&pb&&pa->data.expn>=pb->data.expn){ //当Pa首项的指数大于等于Pb首项的指数
        p=(LNode *)malloc(sizeof(LNode)); //设立新节点保存Pa与Pb首项之商
        if(!p)
	    exit(OVERFLOW);
        p->next=NULL;
        a=pa->data.coef/pb->data.coef;
        b=pa->data.expn-pb->data.expn;
        p->data.coef=a;
        p->data.expn=b;
        Insert(Pc,p); //将得到的商结点插入Pc中
        P=(LNode *)malloc(sizeof(LNode));  //创建临时多项式
        if(!P)
	     exit(OVERFLOW);
        P->next=NULL;
        while(pb) {//遍历Pb中的每一项
            q=(LNode *)malloc(sizeof(LNode)); //设立新节点,保存pb中项与得到的商结点相乘的项
            if(!q)
	            exit(OVERFLOW);
            q->next=NULL;
            q->data.coef=a*pb->data.coef;
            q->data.expn=b+pb->data.expn;
            Insert(P,q); //将得到结点插入临时多项式中
            pb=pb->next;
        }
        DecreasePolyn(Pa,P);//将Pa与临时多项式相减 得到一个新的Pa
        pa=Pa->next;  //获得首项
        pb=Pb->next;
    }
    return OK;
}

进行多项式的求导.

Status PolynDerivative(Polynomial &P){
    //进行多项式的求导
    LNode *p=P->next,*prep=P;
    while(p){  //遍历每一个项
       if(p->data.expn==0){//若指数为零，删除这个项
           prep->next=p->next;
           free(p);
           p=prep->next;
       }
       else{ //指数不为零 修改系数与指数
           p->data.coef*=p->data.expn;
           p->data.expn--;
           prep=p;
           p=p->next;
       }
   }
   return OK;
}