C语言链表实现一元多项式运算器相关功能

已于 2023-11-29 20:42:21 修改
阅读量649 收藏 13
点赞数 3
分类专栏： 数据结构 C/C++ 文章标签： 数据结构 c语言 链表 算法
于 2023-10-11 22:05:58 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_73004416/article/details/133779290
版权

实验内容

（要求：禁止使用STL库)
1.输入并创建多项式（按指数升序或降序排列，系数浮点型，指数整型）；
2. 输出多项式，项数+每项系数指数（按指数升序或降序排列）；
3. 加法；
4. 减法；
5. 求值；
6. 销毁；
7. 清空；
8.修改（①插入新的结点、②删除已有结点、③修改已有结点的系数）；
9. 微分（N阶导数）；
10. 不定积分；
11. 定积分；
12. 乘法和乘方；
13. 除法；
14. 四则运算。


数据组织

1.多项式用带头结点的单链表表示，多项式的项数存放在头结点；
2.用指针数组存放N个多项式的头指针。
 

主要bug（Segmentation fault）的产生原因

1.指针未初始化为NULL就解引用；

2.创建链表时尾指针没有指向NULL（尾插法不熟练导致）;

3.修改链表系列函数的参数一开始不是指针引用而只是指针，这样会导致头指针指向未知的位置，导致接下来调用其他函数时出错；

4.在Division函数里销毁了被除式和除式链表，会导致原链表受到破坏。

另外，正常情况下不会出现内存申请失败的异常，若有，大概率是指针指向出现问题，原因和上面的bug大同小异。

写代码过程中做的较大改进

1.进入相关运算函数后首先判断是否能运算（即链表是否为空或含有0项，注意含有0项和多项式为0是不同的）；

2.把多项式非零次系数为0的项去掉，再统计多项式项数。

另外，本来想用多项式的序号代替多项式进行四则运算，如(1+2)*3表示（1式+2式）*3式，进而需要用栈和逆波兰表示法表示(1+2)*3，但后来发现序号的运算不能代替多项式的运算，因此没能实现对任意输入的多项式进行四则运算（还是用输入(1+2)*3表示（1式+2式）*3式），如有读者有好的想法，还望指教。

源代码

#include <stdio.h>
#include <stdlib.h>
#include<math.h>

typedef struct polynode{//储存多项式项的链表节点
    float coefficient;//系数
    int exponent;//指数
    struct polynode *next;
}Node;

#define LinkNum 2

void printMenu();//打印菜单
void clearCache();//清除缓冲区无用数据
Node* Create();//创建多项式链表
Node* reCreate(Node*);//重建多项式链表
void Print(Node*);//打印多项式链表
Node* Addition(Node*,Node*);//多项式加法
Node* Subtraction(Node*,Node*);//多项式减法
void Evaluate(Node*);//多项式求值
float Evaluate2(Node*,float);//已知未知数的多项式求值
Node* Clear(Node*);//多项式链表清空
void Destroy(Node* &);//多项式链表销毁
void Modify(Node* &);//多项式修改
void InsertNode(Node* &);//插入节点
void DeleteNode(Node* &);//删除节点
void ModifyNode(Node* &);//修改节点
Node* Differential(Node*);//多项式微分
Node* Derivation(Node*);//多项式求高阶导
Node* Indefinite_Integral(Node*);//多项式不定积分
void Definite_Integral(Node*);//多项式定积分
Node* Multiplication(Node*,Node*);//多项式乘法
Node* Exponentiation(Node*);//多项式乘方
Node* DeleteZero(Node*);//把系数为0的非零节点删除
Node* AddZero(Node*);//把稀疏多项式中缺少的次数用0补齐
void Division(Node*,Node*);//多项式除法
Node* NewDivision(Node*,Node*);//舍去余式的多项式除法
void Arithmetic(Node*,Node*);//实现给定的多项式四则运算，除法不保留余式

主函数

int main() {
    char ch;
    Node* headlist[2];
    int i;
    printf("现在开始创建%d个多项式链表\n",LinkNum);
    for(i=0;i<LinkNum;i++){
        printf("第%d个:\n",i+1);
        headlist[i]=Create();
        printf("第%d个",i+1);
        Print(headlist[i]);
        printf("\n");
        clearCache();
    }
    while (1) {
        printMenu();
        printf("请选择对应功能的序号:");
        scanf("%c", &ch);
        clearCache();
        if (ch == 'q')
            break;
        switch (ch) {
            case'a':{//多项式加法
                int i,j;
                printf("请输入进行运算的多项式序号:");
                scanf("%d%d",&i,&j);
                clearCache();
                Node* res1=Addition(headlist[i-1],headlist[j-1]);
                printf("和");
                Print(res1);
                printf("\n");
                Destroy(res1);
                break;
            }
            case'b':{//多项式减法
                int i,j;
                printf("请输入进行运算的多项式序号:");
                scanf("%d%d",&i,&j);
                clearCache();
                Node* res2=Subtraction(headlist[i-1],headlist[j-1]);
                printf("差");
                Print(res2);
                printf("\n");
                Destroy(res2);
                break;
            }
            case'c':{//多项式求值
                int i;
                printf("请输入进行求值的多项式序号:");
                scanf("%d",&i);
                clearCache();
                Evaluate(headlist[i-1]);
                break;
            }
            case'd':{//多项式修改
                int i;
                printf("请输入进行修改的多项式序号:");
                scanf("%d",&i);
                clearCache();
                Modify(headlist[i-1]);
                printf("\n");
                break;
            }
            case'e':{//多项式求导
                int i;
                printf("请输入求导的多项式序号:");
                scanf("%d",&i);
                clearCache();
                Node* res4=Derivation(headlist[i-1]);
                printf("求导后");
                Print(res4);
                printf("\n");
                Destroy(res4);
                break;
            }
            case'f':{//多项式不定积分
                int i;
                printf("请输入求不定积分的多项式序号:");
                scanf("%d",&i);
                clearCache();
                Node* res5=Indefinite_Integral(headlist[i-1]);
                printf("求不定积分后");
                Print(res5);
                printf("+C(常数)\n");
                Destroy(res5);
                break;
            }
            case'g':{//多项式定积分
                int i;
                printf("请输入求定积分的多项式序号:");
                scanf("%d",&i);
                clearCache();
                Definite_Integral(headlist[i-1]);
                break;
            }
            case'h':{//多项式乘法
                int i,j;
                printf("请输入进行运算的多项式序号:");
                scanf("%d%d",&i,&j);
                clearCache();
                Node* res7=Multiplication(headlist[i-1],headlist[j-1]);
                printf("积");
                Print(res7);
                printf("\n");
                Destroy(res7);
                break;
            }
            case'i':{//多项式乘方
                int i;
                printf("请输入求乘方的多项式序号:");
                scanf("%d",&i);
                clearCache();
                Node* res8=Exponentiation(headlist[i-1]);
                printf("求乘方后");
                Print(res8);
                printf("\n");
                Destroy(res8);
                break;
            }
            case'j':{//多项式除法
                int i,j;
                printf("请输入进行运算的多项式序号:");
                scanf("%d%d",&i,&j);
                clearCache();
                Division(headlist[i-1],headlist[j-1]);
                printf("\n");
                break;
            }
            case'k': {//多项式四则运算
                Arithmetic(headlist[0],headlist[1]);
                printf("\n");
                break;
            }
            case'l':{//多项式链表清空重建
                int i;
                printf("请输入需要清空重建的多项式序号:");
                scanf("%d",&i);
                clearCache();
                Node* res11=Clear(headlist[i-1]);
                printf("清空后");
                Print(res11);
                printf("\n");
                Node* head20=reCreate(res11);
                printf("重建后");
                Print(head20);
                printf("\n");
                Destroy(res11);
                Destroy(head20);
                break;
            }
            default:
                break;
        }
    }
    for(i=0;i<LinkNum;i++)
        Destroy(headlist[i]);
    return 0;
}

打印菜单

void printMenu() {//打印菜单
    printf("************************\n");
    printf("一元多项式运算器功能菜单\n");
    printf("************************\n");
    printf("    q、退出\n");
    printf("    a、多项式加法\n");
    printf("    b、多项式减法\n");
    printf("    c、多项式求值\n");
    printf("    d、多项式修改\n");
    printf("    e、多项式求导\n");
    printf("    f、多项式不定积分\n");
    printf("    g、多项式定积分\n");
    printf("    h、多项式乘法\n");
    printf("    i、多项式乘方\n");
    printf("    j、多项式除法\n");
    printf("    k、多项式四则运算\n");
    printf("    l、多项式清空重建\n");
    printf("************************\n");
}

清除缓冲区无用数据

void clearCache(void) {//清除缓冲区无用数据
    while (getchar() != '\n')
        ;
}

把系数为0的非零次节点删除

Node* DeleteZero(Node* head){//把系数为0的非零次节点删除
    Node *p=head->next,*rear=head,*q=NULL;
    int i;
    while (p){
        if(!p->coefficient&&p->exponent){//把非零次项的0系数节点删除
            q=p;
            rear->next=p->next;
            p=p->next;
            free(q);
        }
        else if(rear!=head&&!p->coefficient&&!p->exponent){//把有非零系数的非零次项且末项为0的多项式末项删去
            rear->next=NULL;
            q=p;
            free(q);
            p=NULL;
        }
        else{//当只有一项0时能得以保留
            p=p->next;
            rear=rear->next;
        }
    }
    i=0;
    p=head->next;
    while (p){//遍历得到多项式项数
        i++;
        p=p->next;
    }
    if(i){
        head->exponent=i;
        return head;
    }
    else{//将形如0x^3+0x^2的多项式去掉0系数项后还需补一个0，使其还有一项
        p=(Node*)malloc(sizeof(Node));
        if(!p){
            printf("申请空间失败\n");
            return NULL;
        }
        p->coefficient=0;
        p->exponent=0;
        head->exponent=1;
        p->next=NULL;
        head->next=p;
        return head;
    }
}

尾插法创建与重建多项式链表

Node* Create(){//尾插法创建多项式链表，头节点指数域储存多项式项数，每项次数不小于0
    Node *p=NULL,*head=NULL,*rear=NULL;
    int i,n;
    printf("请输入多项式项数");
    scanf("%d",&n);
    head=(Node*)malloc(sizeof(Node));
    if(!head){
        printf("申请空间失败\n");
        return NULL;
    }
    head->coefficient=0;
    head->next=NULL;
    rear=head;
    if(n){
		printf("请依次输入多项式系数（浮点型)与指数（整型，降序排列且不小于0）");
	    for(i=0;i<n;i++){
	        p=(Node*)malloc(sizeof(Node));
	        if(!p){
	            printf("申请空间失败\n");
	            return NULL;
	        }
	        scanf("%f%d",&p->coefficient,&p->exponent);
            if(p->exponent>=0&&rear!=head&&p->exponent>rear->exponent){
                printf("项要降幂排列\n");
                break;
            }
            else if(p->exponent<0){
                printf("项的次数不能小于零\n");
                break;
            }
            else{
	            rear->next=p;
	            rear=p;
	            rear->next=NULL;
            }
	    }
	    head=DeleteZero(head);
	}
    else
    	head->exponent=0;
    return head;
}

Node* reCreate(Node* given_head){//重建多项式链表，与上面函数类似
    Node *p=NULL,*head=given_head,*rear=NULL;
    int i,n;
    printf("现在重建多项式链表,请输入多项式项数");
    scanf("%d",&n);
    printf("\n");
    head=(Node*)malloc(sizeof(Node));
    if(!head){
        printf("申请空间失败\n");
        return NULL;
    }
    p=head->next=NULL;
    rear=head;
    printf("请依次输入多项式系数（浮点型)与指数（整型，降序排列且不小于0）");
    if(n){
        for(i=0;i<n;i++){
            p=(Node*)malloc(sizeof(Node));
            if(!p){
                printf("申请空间失败\n");
                return NULL;
            }
            scanf("%f%d",&p->coefficient,&p->exponent);
            if(p->exponent>=0&&rear!=head&&p->exponent>rear->exponent){
                printf("项要降幂排列\n");
                break;
            }
            else if(p->exponent<0){
                printf("项的次数不能小于零\n");
                break;
            }
            else{
	            rear->next=p;
	            rear=p;
	            rear->next=NULL;
            }
        }
        head=DeleteZero(head);
    }
    else
        head->exponent=0;
    return head;
}

打印多项式链表

void Print(Node *head){//打印多项式链表成类似5x^3+(-x^2)+1的形式，注意考虑0及系数为正负1和一般正负数时的特殊的打印方式
    if(head){
        Node *p=head;
        printf("多项式有%d项",p->exponent);
        if(p->next){
            p=p->next;
            while(p&&p->next){
                if(!p->coefficient)
                    p=p->next;
                else if(p->exponent>1){
                    if(p->coefficient!=1&&p->coefficient>0){
                        printf("%fx^%d+",p->coefficient,p->exponent);
                        p=p->next;
                    }
                    else if(p->coefficient!=-1&&p->coefficient<0){
                        printf("(%fx^%d)+",p->coefficient,p->exponent);
                        p=p->next;
                    }
                    else if(p->coefficient==-1){
                        printf("(-x^%d)+",p->exponent);
                        p=p->next;
                    }
                    else{
                        printf("x^%d+",p->exponent);
                        p=p->next;
                    }
                }
                else if(p->coefficient!=1&&p->coefficient>0){
                    printf("%fx+",p->coefficient);
                    p=p->next;
                }
                else if(p->coefficient==-1){
                    printf("(-x)+");
                    p=p->next;
                }
                else if(p->coefficient!=-1&&p->coefficient<0){
                    printf("(%fx)+",p->coefficient);
                    p=p->next;
                }
                else{
                    printf("x+");
                    p=p->next;
                }
            }
            if(p->exponent){
                if(p->exponent==1){
                    if(p->coefficient!=-1&&p->coefficient<0)
                        printf("(%fx)",p->coefficient);
                    else if(p->coefficient==-1)
                        printf("(-x)");
                    else if(p->coefficient!=1&&p->coefficient>0)
                        printf("%fx",p->coefficient);
                    else
                        printf("x");
                }
                else if(p->coefficient<0&&p->coefficient!=-1)
                    printf("(%fx^%d)",p->coefficient,p->exponent);
                else if(p->coefficient==-1)
                    printf("(-x^%d)",p->exponent);
                else if(p->coefficient!=1&&p->coefficient>0)
                    printf("%fx^%d",p->coefficient,p->exponent);    
                else
                    printf("x^%d",p->exponent);
            }
            else{
                if(p->coefficient>=0)
                    printf("%f",p->coefficient);
                else if(p->coefficient<0)
                    printf("(%f)",p->coefficient);
            }
        }
    }
    else
        printf("多项式无法打印");
}

多项式加法与减法

Node* Addition(Node* head1,Node* head2){//多项式加法，把结果储存到一个新链表
    if(!head1||!head2){
		printf("\n进行加法运算的多项式不能没有项\n");
		return NULL;
	}
    Node *node=(Node*)malloc(sizeof(Node)),*p=head1->next,*q=head2->next,*rear=NULL,*pt=NULL;
    if(!node){
        printf("申请空间失败\n");
        return NULL;
    }
    int i=0;
    node->next=NULL;
    pt=node;
    while(p&&q){
		if(p->exponent>q->exponent){
			rear=(Node*)malloc(sizeof(Node));
			if(!rear){
				printf("申请空间失败\n");
				return NULL;
			}
			rear->coefficient=p->coefficient;
			rear->exponent=p->exponent;
			p=p->next;
		}
		else if(q->exponent>p->exponent){
			rear=(Node*)malloc(sizeof(Node));
			if(!rear){
				printf("申请空间失败\n");
				return NULL;
			}
			rear->coefficient=q->coefficient;
			rear->exponent=q->exponent;
			q=q->next;
		}
		else{
			rear=(Node*)malloc(sizeof(Node));
			if(!rear){
				printf("申请空间失败\n");
				return NULL;
			}
			rear->coefficient=p->coefficient+q->coefficient;
			rear->exponent=q->exponent;
			q=q->next;
			p=p->next;
		}
		pt->next=rear;
		pt=rear;
		pt->next=NULL;
	}
	while(!p&&q){
		rear=(Node*)malloc(sizeof(Node));
		if(!rear){
			printf("申请空间失败\n");
			return NULL;
		}
		rear->coefficient=q->coefficient;
		rear->exponent=q->exponent;
		q=q->next;
		pt->next=rear;
		pt=rear;
		pt->next=NULL;
	}
	while(!q&&p){
		rear=(Node*)malloc(sizeof(Node));
		if(!rear){
			printf("申请空间失败\n");
			return NULL;
		}
		rear->coefficient=p->coefficient;
		rear->exponent=p->exponent;
		p=p->next;
		pt->next=rear;
		pt=rear;
		pt->next=NULL;
	}
    node=DeleteZero(node);
    return node;
}

Node* Subtraction(Node* head1,Node* head2){//多项式减法，把结果储存到一个新链表，与加法基本相同，只是符号有差别
    if(!head1||!head2){
		printf("进行运算的多项式不能没有项\n");
		return NULL;
	}
	Node *node=(Node*)malloc(sizeof(Node)),*p=head1->next,*q=head2->next,*rear=NULL,*pt=NULL;
    if(!node){
        printf("申请空间失败\n");
        return NULL;
    }
    int i=0;
    node->next=NULL;
    pt=node;
    while(p&&q){
		if(p->exponent>q->exponent){
			rear=(Node*)malloc(sizeof(Node));
			if(!rear){
				printf("申请空间失败\n");
				return NULL;
			}
			rear->coefficient=p->coefficient;
			rear->exponent=p->exponent;
			p=p->next;
		}
		else if(q->exponent>p->exponent){
			rear=(Node*)malloc(sizeof(Node));
			if(!rear){
				printf("申请空间失败\n");
				return NULL;
			}
			rear->coefficient=-q->coefficient;
			rear->exponent=q->exponent;
			q=q->next;
		}
		else{
			rear=(Node*)malloc(sizeof(Node));
			if(!rear){
				printf("申请空间失败\n");
				return NULL;
			}
			rear->coefficient=p->coefficient-q->coefficient;
			rear->exponent=q->exponent;
			q=q->next;
			p=p->next;
		}
		pt->next=rear;
		pt=rear;
		pt->next=NULL;
	}
	while(!p&&q){
		rear=(Node*)malloc(sizeof(Node));
		if(!rear){
			printf("申请空间失败\n");
			return NULL;
		}
		rear->coefficient=-q->coefficient;
		rear->exponent=q->exponent;
		q=q->next;
		pt->next=rear;
		pt=rear;
		pt->next=NULL;
	}
	while(!q&&p){
		rear=(Node*)malloc(sizeof(Node));
		if(!rear){
			printf("申请空间失败\n");
			return NULL;
		}
		rear->coefficient=p->coefficient;
		rear->exponent=p->exponent;
		p=p->next;
		pt->next=rear;
		pt=rear;
		pt->next=NULL;
	}
    node=DeleteZero(node);
    return node;
}

未知未知数的多项式求值

void Evaluate(Node* head){//未知未知数的多项式求值
    if(!head)
        printf("\n进行运算的多项式不能没有项\n");
    else{
        Node *p=head->next;
        float x,val=0;
        printf("请输入未知数的值（浮点型）");
        scanf("%f",&x);
        printf("\n");
        while(p){
            double temp=p->exponent;
            val=val+(p->coefficient*pow(x,temp));
            p=p->next;
        }
        printf("x=%f时,多项式的值为%f\n",x,val);
    }
}

已知未知数的多项式求值

float Evaluate2(Node* head,float x){//已知未知数的多项式求值，可用于求定积分
    if(!head){
		printf("\n进行运算的多项式不能没有项\n");
		return 0;
    }
    else{
        Node *p=head->next;
        float val=0;
        while(p){
            double temp=p->exponent;
            val=val+(p->coefficient*pow(x,temp));
            p=p->next;
        }
        clearCache();
        return val;
    }
}

多项式链表销毁

void Destroy(Node* &head){//多项式链表销毁
    Node *p=head,*temp;
    while(p){
        temp=p;
        p=p->next;
        free(temp);
    }
}

多项式链表清空

Node* Clear(Node* head){//多项式链表清空
    if(!head){
        printf("\n链表不能为空\n");
        return NULL;
    }
    if(!head->next){
		printf("\n链表已为空\n");
		return NULL;	
	}
    Node *p=head->next;
    head->exponent=0;
    Destroy(p);
    head->next=NULL;
    return head;
}

插入节点

void InsertNode(Node* &head){//插入节点
    if(!head)
        printf("\n进行插入的多项式不能没有项\n");
    else{
        Node *p=head->next,*node=NULL;
        float coef;
        int exp;
        printf("请输入要插入节点的系数(浮点型)和指数(整型)");
        scanf("%f%d",&coef,&exp);
        clearCache();
        if(!p){
            head->next=node;
            node->coefficient=coef;
            node->exponent=exp;
            head->next->next=NULL;
            head->exponent++;
            return ;
        }
        while(p){
            if(p->exponent<exp){
                node=(Node*)malloc(sizeof(Node));
                if(!node)
                    printf("申请空间失败\n");
                node->next=p;
                head->next=node;
                node->coefficient=coef;
                node->exponent=exp;
                head->exponent++;
                return ;
            }
            else if(p->exponent>exp&&p->next->exponent>exp)
                p=p->next;
            else if(p->exponent>exp&&p->next->exponent<exp){
                node=(Node*)malloc(sizeof(Node));
                if(!node)
                    printf("申请空间失败\n");
                node->next=p->next;
                p->next=node;
                node->coefficient=coef;
                node->exponent=exp;
                head->exponent++;
                return ;
            }
            else if(p->exponent==exp)
                p->coefficient=p->coefficient+coef;
            else if(p->exponent>exp&&!p->next){
                node=(Node*)malloc(sizeof(Node));
                if(!node)
                    printf("申请空间失败\n");
                p->next=node;
                node->coefficient=coef;
                node->exponent=exp;
                p->next->next=NULL;
                head->exponent++;
                return ;
            }
        }
    }
}

删除节点

void DeleteNode(Node* &head){//删除节点
    if(!head)
        printf("\n进行插入的多项式不能没有项\n");
    else{
        Node *p=head->next,*prior=head;
        int exp;
        printf("请输入要删除节点的指数(整型)");
        scanf("%d",&exp);
        clearCache();
        while(p){
            if(p->exponent==exp){
                prior->next=p->next;
                free(p);
                head->exponent--;
                return ;
            }
            p=p->next;
            prior=prior->next;
        }
        printf("找不到要删除指数对应的项");
        return ;
    }
}

修改节点

void ModifyNode(Node* &head){//修改节点
    if(!head)
        printf("\n进行插入的多项式不能没有项\n");
    else{
        Node *p=head->next;
        float coef;
        int exp;
        printf("请输入要修改节点的指数(整型)");
        scanf("%d",&exp);
        clearCache();
        while(p){
            if(p->exponent==exp){
                printf("请输入修改节点后的系数(浮点型)");
                scanf("%f",&coef);
                clearCache();
                p->coefficient=coef;
                return ;
            }
            p=p->next;
        }
        printf("找不到要修改指数对应的项");
        return ;
    }
}

多项式修改

void Modify(Node* &head){//多项式修改
    char ch;
    while (1) {
        printf("************************\n");
        printf("    q、退出\n");
        printf("    a、插入节点\n");
        printf("    b、删除节点\n");
        printf("    c、修改节点\n");
        printf("************************\n");
        printf("请选择对应功能的序号：");
        scanf("%c", &ch);
        clearCache();
        printf("\n");
        if (ch == 'q')
            break;
        switch (ch) {
            case'a':{
                InsertNode(head);
                printf("插入节点后");
                Print(head);
                printf("\n");
                break;
            }
            case'b':{
                DeleteNode(head);
                printf("删除节点后");
                Print(head);
                printf("\n");
                break;
            }
            case'c':{
                ModifyNode(head);
                printf("修改节点后");
                Print(head);
                printf("\n");
                break;
            }
            default:
                break;
        }
    }
}

多项式微分与求高阶导

Node* Differential(Node* head){//多项式微分，把结果储存到一个新链表
    if(!head){
		printf("\n进行求微分运算的多项式不能没有项\n");
		return NULL;
	}
    Node* node=(Node*)malloc(sizeof(Node)),*rear=NULL,*q=NULL,*p=head->next;
    int i;
    if(!node){
        printf("申请空间失败\n");
        return NULL;
    }
    q=node->next;
    rear=node;
    for(i=0;i<head->exponent&&p->exponent;i++){
        q=(Node*)malloc(sizeof(Node));
        if(!q){
            printf("申请空间失败\n");
            return NULL;
        }
        q->coefficient=p->coefficient*p->exponent;
        q->exponent=p->exponent-1;
        rear->next=q;
        rear=q;
        rear->next=NULL;
        p=p->next;
    }
    node=DeleteZero(node);
    return node;
}

Node* Derivation(Node* head){//反复调用求微分的函数求高阶导，把结果储存到一个新链表
    if(!head){
		printf("\n进行求高阶导运算的多项式不能没有项\n");
		return NULL;
	}
    int n,i;
    printf("请输入求导阶数");
    scanf("%d",&n);
    clearCache();
    Node* node=head;
    for(i=0;i<n;i++){
        node=Differential(node);
        if(!node){
            printf("求导异常\n");
            return NULL;
        }
    }
    node=DeleteZero(node);
    return node;
}

多项式不定积分

Node* Indefinite_Integral(Node* head){//多项式不定积分，把结果储存到一个新链表
    if(!head->next||!head){
		printf("\n进行求不定积分运算的多项式不能没有项\n");
		return NULL;
	}
    Node *node=(Node*)malloc(sizeof(Node)),*rear=NULL,*q=NULL,*p=head;
    int i;
    if(!node){
        printf("申请空间失败\n");
        return NULL;
    }
    q=node->next;
    p=p->next;
    rear=node;
    for(i=0;i<head->exponent;i++){
        q=(Node*)malloc(sizeof(Node));
        if(!q){
            printf("申请空间失败\n");
            return NULL;
        }
        q->coefficient=p->coefficient/(p->exponent+1);
        q->exponent=p->exponent+1;
        rear->next=q;
        rear=q;
        rear->next=NULL;
        p=p->next;
    }
    node=DeleteZero(node);
    node->exponent++;//因为还有一个常数项
    return node;
}

多项式定积分

void Definite_Integral(Node* head){//多项式定积分
    if(!head)
        printf("\n进行求定积分运算的多项式不能没有项\n");
    else{
        Node *node=(Node*)malloc(sizeof(Node)),*rear=NULL,*q=NULL,*p=head;
        int i;
        float lower,upper;
        if(!node)
            printf("申请空间失败\n");
        q=node->next;
        p=p->next;
        rear=node;
        for(i=0;i<head->exponent;i++){
            q=(Node*)malloc(sizeof(Node));
            if(!q)
                printf("申请空间失败\n");
            q->coefficient=p->coefficient/(p->exponent+1);
            q->exponent=p->exponent+1;
            rear->next=q;
            rear=q;
            rear->next=NULL;
            p=p->next;
        }
        node=DeleteZero(node);
        printf("请分别输入积分下限和上限（浮点数）");
        scanf("%f%f",&lower,&upper);
        clearCache();
        printf("以%f和%f作为积分下上限的定积分结果是%f\n",lower,upper,Evaluate2(node,upper)-Evaluate2(node,lower));
        Destroy(node);
    }
}

多项式乘法与乘方

Node* Multiplication(Node* head1,Node* head2){//多项式乘法，把结果储存到一个新链表。原理是用第一个乘数的每一项依次乘以第二个乘数后依次把结果的头指针储存到一个长为head1->exponent的指针数组里
    if(!head1||!head2){
		printf("\n进行乘法运算的多项式不能没有项\n");
		return NULL;
	}
    Node *node=NULL,*p=head1,*q=head2->next,*list[head1->exponent];
    int i;
    for(i=0;i<head1->exponent;i++){
        p=p->next;
        list[i]=(Node*)malloc(sizeof(Node));
        if(!list){
            printf("申请空间失败\n");
            return NULL;
        }
        list[i]->exponent=head2->exponent;
        Node *rear=NULL,*pt=list[i];
        while (q){
            rear=(Node*)malloc(sizeof(Node));
            if(!rear){
                printf("申请空间失败\n");
                return NULL;
            }
            rear->exponent=p->exponent+q->exponent;
            rear->coefficient=p->coefficient*q->coefficient;
            q=q->next;
            pt->next=rear;
            pt=rear;
            pt->next=NULL;
        }
        q=head2->next;
    }
    for(i=1;i<head1->exponent;i++)//将指针数组里的多项式累加得到结果
        list[i]=Addition(list[i-1],list[i]);
    node=list[head1->exponent-1];
    node=DeleteZero(node);
    for(i=0;i<head1->exponent-1;i++)
        Destroy(list[i]);
    return node;
}

Node* Exponentiation(Node* head){//反复调用乘法函数求多项式乘方，把结果储存到一个新链表
    if(!head){
		printf("\n进行乘方运算的多项式不能没有项\n");
		return NULL;
	}
    int i,n;
    printf("请输入次方数");
    scanf("%d",&n);
    clearCache();
    Node* list[n];
    list[0]=head;
    for(i=1;i<n;i++)//将原多项式乘上n次
        list[i]=Multiplication(head,list[i-1]);
    list[n-1]=DeleteZero(list[n-1]);
    for(i=0;i<n-1;i++)
        Destroy(list[i]);
    return list[n-1];
}

对稀疏多项式中缺少的次数把0设为其系数

Node* AddZero(Node* head){//把稀疏多项式中缺少的次数用0补齐，用于除法函数的被除式
    Node *p=head->next,*rear=NULL;
    while(p){
        if(p->next&&p->next->exponent!=p->exponent-1){
            rear=(Node*)malloc(sizeof(Node));
            if(!rear){
                printf("申请空间失败\n");
                return NULL;
            }
            rear->coefficient=0;
            rear->exponent=p->exponent-1;
            rear->next=p->next;
            p->next=rear;
        }
        else if(!p->next&&p->exponent){
            rear=(Node*)malloc(sizeof(Node));
            if(!rear){
                printf("申请空间失败\n");
                return NULL;
            }
            rear->coefficient=0;
            rear->exponent=p->exponent-1;
            p->next=rear;
			p->next->next=NULL;
        }
        p=p->next;
    }
    p=head->next;
    int i=0;
    while (p){
        i++;
        p=p->next;
    }
    head->exponent=i;
    return head;
}

多项式除法（包括保留余式和舍去余式两种）

void Division(Node* head1,Node* head2){//多项式除法，打印商式和余式
    if(!head1||!head2)
        printf("\n进行除法运算的多项式不能没有项\n");
    else{
        Node *Dividend=AddZero(head1),*Divisor=DeleteZero(head2);
        if(!Divisor->next->coefficient)
            printf("除数不能为零！");
        Node *Remainder=Dividend,*Quotient=(Node*)malloc(sizeof(Node)),*p=NULL,*rear=NULL;//Dividen表示被除式指针，Divisor表示除式指针，Quotient表示商式指针，Remainder表示余式指针
        if(!Quotient)
            printf("申请空间失败\n");
        rear=Quotient;
        rear->exponent=1;//首先把商式置为0
        rear->next=NULL;
        p=(Node*)malloc(sizeof(Node));
        if(!p)
            printf("申请空间失败\n");
        p->coefficient=0;
        p->exponent=0;
        rear->next=p;
        rear=p;
        rear->next=NULL;
		Remainder=Subtraction(Remainder,Multiplication(Quotient,Divisor));
        while (Remainder->next->exponent>Divisor->next->exponent){//余式次数高于除式，进入循环
            Node* pt=Remainder->next;
            if(!rear->coefficient&&!rear->exponent){//初始状态商式为0时
                rear->coefficient=pt->coefficient/Divisor->next->coefficient;
                rear->exponent=pt->exponent-Divisor->next->exponent;
            }
            else
            {
                p=(Node*)malloc(sizeof(Node));
                if(!p)
                    printf("申请空间失败\n");
                p->coefficient=pt->coefficient/Divisor->next->coefficient;
                p->exponent=pt->exponent-Divisor->next->exponent;
                rear->next=p;
                rear=p;
                rear->next=NULL;
            }
            Node *temp=(Node*)malloc(sizeof(Node));//temp的内容为商式的最后一项
            if(!temp){
                printf("申请空间失败\n");
                break;
            }
            temp->exponent=1;
            temp->next=(Node*)malloc(sizeof(Node));
            if(!temp->next){
                printf("申请空间失败\n");
                break;
            }
            temp->next->coefficient=rear->coefficient;
            temp->next->exponent=rear->exponent;
            temp->next->next=NULL;
            Remainder=Subtraction(Remainder,Multiplication(temp,Divisor));
        }
		if(Remainder->next->exponent==Divisor->next->exponent){//余式次数等于除式
			Node* pt=Remainder->next;
            if(!rear->coefficient&&!rear->exponent){
                rear->coefficient=pt->coefficient/Divisor->next->coefficient;
                rear->exponent=pt->exponent-Divisor->next->exponent;
            }
            else{
                p=(Node*)malloc(sizeof(Node));
                if(!p)
                    printf("申请空间失败\n");
                p->coefficient=pt->coefficient/Divisor->next->coefficient;
                p->exponent=pt->exponent-Divisor->next->exponent;
                rear->next=p;
                rear=p;
                rear->next=NULL;
            }
            Node *temp=(Node*)malloc(sizeof(Node));
            if(!temp)
                printf("申请空间失败\n");
            temp->exponent=1;
            temp->next=(Node*)malloc(sizeof(Node));
            if(!temp->next)
                printf("申请空间失败\n");
            temp->next->coefficient=rear->coefficient;
            temp->next->exponent=rear->exponent;
            temp->next->next=NULL;
            Remainder=Subtraction(Remainder,Multiplication(temp,Divisor));
		}
        Quotient=DeleteZero(Quotient);
        printf("商");
        Print(Quotient);
        printf("\n");
        Remainder=DeleteZero(Remainder);
        printf("余");
        Print(Remainder);
        Destroy(Remainder);
        printf("\n");
    }
}

Node* NewDivision(Node* head1,Node* head2){//舍去余式的多项式除法，返回商式
    if(!head1||!head2){
        printf("\n进行除法运算的多项式不能没有项\n");
        return NULL;
    }
    else{
        Node *Dividend=AddZero(head1),*Divisor=DeleteZero(head2);
        if(!Divisor->next->coefficient)
            printf("除数不能为零！");
        Node *Remainder=Dividend,*Quotient=(Node*)malloc(sizeof(Node)),*p=NULL,*rear=NULL;//Dividen表示被除式指针，Divisor表示除式指针，Quotient表示商式指针，Remainder表示余式指针
        if(!Quotient)
            printf("申请空间失败\n");
        rear=Quotient;
        rear->exponent=1;//首先把商式置为0
        rear->next=NULL;
        p=(Node*)malloc(sizeof(Node));
        if(!p)
            printf("申请空间失败\n");
        p->coefficient=0;
        p->exponent=0;
        rear->next=p;
        rear=p;
        rear->next=NULL;
		Remainder=Subtraction(Remainder,Multiplication(Quotient,Divisor));
        while (Remainder->next->exponent>Divisor->next->exponent){//余式次数高于除式，进入循环
            Node* pt=Remainder->next;
            if(!rear->coefficient&&!rear->exponent){//初始状态商式为0时
                rear->coefficient=pt->coefficient/Divisor->next->coefficient;
                rear->exponent=pt->exponent-Divisor->next->exponent;
            }
            else{
                p=(Node*)malloc(sizeof(Node));
                if(!p)
                    printf("申请空间失败\n");
                p->coefficient=pt->coefficient/Divisor->next->coefficient;
                p->exponent=pt->exponent-Divisor->next->exponent;
                rear->next=p;
                rear=p;
                rear->next=NULL;
            }
            Node *temp=(Node*)malloc(sizeof(Node));//temp的内容为商式的最后一项
            if(!temp){
                printf("申请空间失败\n");
                break;
            }
            temp->exponent=1;
            temp->next=(Node*)malloc(sizeof(Node));
            if(!temp->next){
                printf("申请空间失败\n");
                break;
            }
            temp->next->coefficient=rear->coefficient;
            temp->next->exponent=rear->exponent;
            temp->next->next=NULL;
            Remainder=Subtraction(Remainder,Multiplication(temp,Divisor));
        }
		if(Remainder->next->exponent==Divisor->next->exponent){//余式次数等于除式
			Node* pt=Remainder->next;
            if(!rear->coefficient&&!rear->exponent){
                rear->coefficient=pt->coefficient/Divisor->next->coefficient;
                rear->exponent=pt->exponent-Divisor->next->exponent;
            }
            else{
                p=(Node*)malloc(sizeof(Node));
                if(!p)
                    printf("申请空间失败\n");
                p->coefficient=pt->coefficient/Divisor->next->coefficient;
                p->exponent=pt->exponent-Divisor->next->exponent;
                rear->next=p;
                rear=p;
                rear->next=NULL;
            }
            Node *temp=(Node*)malloc(sizeof(Node));
            if(!temp)
                printf("申请空间失败\n");
            temp->exponent=1;
            temp->next=(Node*)malloc(sizeof(Node));
            if(!temp->next)
                printf("申请空间失败\n");
            temp->next->coefficient=rear->coefficient;
            temp->next->exponent=rear->exponent;
            temp->next->next=NULL;
            Remainder=Subtraction(Remainder,Multiplication(temp,Divisor));
		}
        Quotient=DeleteZero(Quotient);
        Destroy(Remainder);
        return Quotient;
    }
}

实现给定的多项式四则运算，除法不保留余式

void Arithmetic(Node* head1,Node* head2){//实现给定的多项式四则运算，除法不保留余式
	printf("(1式+2式)*1式/2式后");
    Print(NewDivision(Multiplication(Addition(head1,head2),head1),head2));
}

千里澄江
关注
  • 3
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
C语言 线性表实现一元多项式的表示及相加
yuxi___的博客
05-16 5417
解题思路 1.储存系数与项数 储存结构：若只进行求值操作，不改变多项式的系数或指数，那么用顺序结构更方便些。否则，用链式结构效率更高。我们采取连式结构。 储存多项式信息：从上图可以看出，一个多项式中的一项有系数、指数两项。所以在设计结点时，应有三个域：系数、指数、next 2.要实现的操作 1.两个多项式相加 在进行操作之前，我们可以先建一个新的链表（“和多项式”链表），用来保存相加的结果。 （1）指针qa所指结点的指数 == 指针qb所指结点的指数 将两个结点中的系数相加，若和不为0，则修改qa所指结点的
C语言单链表实现多项式
m0_57625433的博客
04-27 1797
C语言单链表实现多项式 一、多项式的存储结构 注意：多项式每项的指数必须递增 typedef struct PNode{ int coef; //系数 int expn; //指数 struct PNode *next; //指针域 }PNode,*Polynomial; 二、多项式的创建 与创建链表相似，但需要多声明前驱指针pre来辅助节点的添加。 void CreatPolyn(Polynomial &P,int n){ P=(Polynomial)malloc(sizeof(PNo
数据结构（C语言）：一元多项式的操作（链表实现）
lbcbjtlhmjq的博客
05-23 1911
设有两个一元多项式：多项式项的系数为实数，指数为整数，设计实现一元多项式操作的程序：① 多项式链表建立：以（系数，指数）方式输入项建立多项式，返回所建立的链表的头结点；② 多项式排序：将所建立的多项式按指数非递减（从小到大）进行排序；③ 多项式相加：实现两个多项式相加操作。操作生成一个新的多项式，原有的两个多项式不变，返回生成的多项式的头结点；④ 多项式的输出；⑤ 主函数通过调用多项式链表建立函数，输入两个多项式并分别输出；输出排序后的两个多项式；
c语言 一元多项式乘法,一元多项式的加法、减法、乘法和微分运算的C语言链表结构算法实现...
weixin_36151775的博客
05-17 1005
问题描述：利用链表实现一元多项式的数学运算。如一元多项式可以利用其系数????和指数????组合的方式实现链式存储。通过对线性表的基本操作，例如插入，删除，查找等可以实现一元多项式的复杂运算，比如加，减，乘，除等运算。基本要求：利用链表存储一元多项式，通过对链表的操作实现多项式的运算。测试数据：对于多项式：????(????) = 7 + 3???? + 9???? + 5????，????(????) = 8???? + 22???? − 9????，实现加，减，乘...
一元多项式的链式表示-C语言实现
qq_53830608的博客
01-15 1259
思考：f(x)=4+3x+x^2,如何保存？ 1.顺序表：只保存系数，指数就是下标，如图所示。 有效数据为3，总长度为5（5个格子） 问题：如果多项式为h(x)=1+3x^100+4x^200，这样的多项式过于稀疏，存储起来会浪费内存，顺序表长度至少为201，但是只存储了3个数字。因此选用链表 2. 链表：每个节点数据保存系数+指数，如图所示。 好处：多项式主要是用来进行运算，链表的插入和删除操作相对于顺序表更方便 基本操作： 多项式的加法、减法、插入、删除、查找、输出。.
C语言实现一元多项式的加减乘
11-27
C语言实现一元多项式的加法，减法，乘法。标注不错但是程序比较简单！
一元多项式的相除操作(链表)
编程技巧分享
04-18 467
一元多项式的除法运算如何实现，要求多项式采用链表存储结构，不必利用比对两个多项式的公因式的方法将分式化为最简形式，建议采用综合除法。 这个题目原来是要求利用寻找公因式的方法将分式化为最简形式，但是呢，由于求解高次多项式的因式的操作涉及解方程的操作，而方程又不一定有实数范围内的实根，就算有也不一定是整数根，此类种种会导致用计算机实现一元多项式的除法操作异常地耗时、困难，所以以我个人的能力只能利用综合除法实现一元多项式的除法操作。至于其它各种用于一元多项式除法的方法，我上传到了自己的文档中.....
c语言用链表写出多项式加法,C语言：用链表实现一元多项式的加法
weixin_39605894的博客
05-23 371
/*一元多多项式的加法1.先创建链表，存储多项式2.输出多项式3.两个多项式相加4.输出多项式*/# include # include typedef struct dxs //多项式节点{float coe; //系数int exp; //指数struct dxs * pNext; //指针域}DXS, * PDXS;PDXS creat_dxs(); //创建多项式void t...
数据结构实验：线性表（一元多项式相加）
comchk的博客
11-22 3063
一、【实验目的】 1、掌握线性表的链式存储结构； 2、掌握链表的基本操作，并能进行应用实践； 3、使用C/C++语言和线性表实现“一元多项式相加”专题。 二、【实验内容】 结合课本第41页的例子，采用链式存储结构，将两个线性链表表示的一元多项式相加，并输出。此一元多项式遵循多项式相加运算规则：对于两个一元多项式中存在指数相同的项时，其对应系数相加：合并时系数和为零时，删除“和多项式”中此项；合并时系数和不为零时，则构成“和多项式”中的一项。对于两个一元多项式中存在的指数不相同的项，则分别复抄到
一元多项式的加减 c语言链表实现
weixin_45841571的博客
06-20 2758
一元多项式的加减 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 +3.00x^1000 减法运算结果： d(x)=-7.00 -4.00x+8.00x^3 -1.00x99+3.00x1000 (2)a(x)= 3x^5 +7x^3+1 b(x)=9x^6 -7x3+4x2+5x-1 加法运
多项式运算多项式运算
01-06
在IT领域，多项式运算是一项基础且重要的数学概念，它被广泛应用于计算机科学的多个分支，如数值计算、符号计算、计算机图形学等。这里我们将深入探讨如何在编程环境中实现这些运算，主要针对C语言环境。 首先，...
用C语言实现多项式加减法
05-25
本篇将详细探讨如何使用C语言，结合链表数据结构，来实现多项式的加减操作。链表是一种灵活的数据结构，非常适合表示多项式，因为它可以动态地存储不同指数的系数，而无需预先确定系数的数量。 首先，我们需要定义...
数据结构各章节算法实现（C语言版）.docx
10-12
- **一元多项式相加**：实现两个一元多项式的加法运算，可以是直接相加或保持原链表信息。 2. **栈和队列**：栈是后进先出（LIFO）的数据结构，队列则是先进先出（FIFO）的数据结构。 - **行编辑器**：利用栈实现...
数据结构课程设计----一元稀疏多项式计算器
05-18
4. **多项式运算**： - **加法与减法**：对于两个稀疏多项式，我们可以遍历两个链表，对于相同指数的项进行相加或相减，如果一个链表中有某个指数的项而另一个没有，则保留原有的项。结果同样存储在链表中。 - **...
中国海洋大学_数据结构与算法课程实验_多项式运算，迷宫问题，哈夫曼编码，最短路径问题
06-04
本实验旨在通过C语言这一强大的编程工具，深入探讨多项式运算、迷宫问题、哈夫曼编码以及最短路径问题等经典算法。实验采用GCC编译器与codeblocks mingw开发环境，确保了程序的高效运行和调试。 首先，我们来看...
c语言数据结构线性表-链表----一元多项式相加
精神病小麦的博客
11-27 2345
c语言数据结构线性表-链表----一元多项式相加 作业 ：用链表创建两个一元多项式,并实现两个多项式相加 功能实现 尾插法创建单链表 两式相加 打印 #include<stdio.h> #include<stdlib.h> #define length sizeof(struct Polynode) //定义节点结构 typedef struct Polynode {...
c语言如何存储多项式,数据结构(C语言)用单链表存储一元多项式,并实现两个多项式的相加运算...
weixin_35677065的博客
05-17 1118
数据结构(C语言)用单链表存储一元多项式,并实现两个多项式的相加运算 #include #include #include typedef int ElemType; /*单项链表的声明*/ typedef struct PolynNode{ int coef; // 系数 int expn; // 指数 struct PolynNode *next; }PolynNode,*PolynList;...
C语言实现数据结构之一元多项式计算
最新发布
m0_60388174的博客
01-22 1144
需要输入的信息有多项式的系数和指数，用来向系统动态申请内存；系数和指数用来构造每个结点，形成表。由于每次输入的多项式项数不确定，所以使用顺序表的链式存储。在此除了题目要求的加减运算，我还增加了乘法运算。设计合适的存储结构，完成一元多项式的相关运算。
用链表实现多项式的相关运算
Mr_DJY的博客
04-03 558
数据结构

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

千里澄江

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值