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

    2018-04-05 16:24:25
    加减乘除求导积分求值 加减乘除求导积分求值 加减乘除求导积分求值 加减乘除求导积分求值
  • 一元多项式运算

    2020-12-23 22:17:18
    本实验要求以链表为存储结构,设计一个一元多项式运算器,实现一元多项式的创建、销毁、复制、打印显示、四则运算等功能。 三、实验内容 实现一元多项式运算器的基本功能: (1)创建多项式; (2)打印显示多项式; (3)...

    一元多项式的运算

    一、实验目的
    1.熟练掌握C/C++语言中指针的操作。
    2.掌握链表的常用算法。

    二、问题描述

    一元多项式可以表示为线性表,相应地一元多项式的运算可以用线性表的基本运算来实现。本实验要求以链表为存储结构,设计一个一元多项式运算器,实现一元多项式的创建、销毁、复制、打印显示、四则运算等功能。

    三、实验内容
    实现一元多项式运算器的基本功能:
    (1)创建多项式;
    (2)打印显示多项式;
    (3)销毁多项式;
    (4)复制多项式;
    (5)求两个多项式的和;
    (6)求两个多项式的差;
    (7)求两个多项式的积;
    (8)求一个多项式的n次幂;
    (9)计算一个多项式在x=a处的值。

    四、实现提示

    1. 由于程序有多项功能,可采用菜单选项的方式来分别调用各项功能。
    2. 销毁多项式时,要注意释放所有结点的存储空间。
    3. 求两个多项式的积可分解为一系列多项式求和运算。
    
    ```c
    #include<stdio.h>
    #include<math.h>
    #include<stdlib.h>
    typedef struct {
    	float coef;
    	int expn;
    }Datatype;
    typedef struct Node {
    	Datatype data;
    	struct Node* next;
    }Listnode, * Linklist;
    //查找定位算法
    int LocateNode(Linklist L, Datatype e, int& q) {
    	Listnode* p = L->next;
    	q = 0;//记录节点位置序号
    	while (p && e.expn < p->data.expn) {
    		p = p->next; q++;
    	}
    	if (p == NULL || e.expn != p->data.expn)
    		return(0);//查找失败
    	else
    		return 1;
    }
    //在有序表中插入一个数据后仍保持表的有序性
    void InsertNode(Linklist& L, Datatype e, int q) {
    	Listnode* s, * p;
    	int i = 0;
    	p = L;
    	while (p->next && i < q) {
    		p = p->next;
    		i++;
    	}//查找插入位置
    	s = (Listnode*)malloc(sizeof(Listnode));
    	s->data.coef = e.coef;
    	s->data.expn = e.expn;
    	s->next = p->next;
    	p->next = s;
    }
    //多项式复制,将多项式La复制到Lc中
    void CopyPolyn(Linklist La, Linklist& Lc) {
    	Listnode* p, * q, * pc;
    	p = La->next;
    	Lc = (Linklist)malloc(sizeof(Listnode));
    	q = Lc;
    	pc = Lc;
    	while (p) {
    		pc = (Linklist)malloc(sizeof(Listnode));
    		pc->next = NULL;
    		q->next = pc;
    		pc->data.coef = p->data.coef;
    		pc->data.expn = p->data.expn;
    		q = q->next;
    		p = p->next;
    	}
    }
    //创建多项式
    void CreatPolyn(Linklist& L, int n) {
    	Linklist pa; int i, q;
    	Datatype e;
    	pa = (Listnode*)malloc(sizeof(Listnode));//生成链表的头节点
    	pa->next = NULL;
    	for (i = 0; i < n; i++) {
    		scanf("%f,%d", &e.coef, &e.expn);
    		if (!LocateNode(pa, e, q))//当前列表中不存在该指数项
    			InsertNode(pa, e, q);
    	}
    	L = pa;
    }
    //多项式链表的打印
    void PrintList(Linklist L) {
    	Listnode* p;
    	p = L->next;
    	while (p) {
    		printf("%c %.3fX^%d", (p->data.coef > 0 ? '+' : ' '), p->data.coef, p->data.expn);
    		p = p->next;
    	}
    	printf("\n");
    }
    //多项式链表的相加
    void AddPolyn(Linklist La, Linklist Lb, Linklist& Lc) {
    	//两个有序多项式La Lb得到Lc
    	Listnode* pa, * pb, * pc, * s;
    	Linklist w, v;
    	CopyPolyn(Lb, w);
    	CopyPolyn(La, v);
    	float sum;
    	pa = v->next;
    	pb = w->next;
    	Lc = pc = v;
    	while (pa && pb) {
    		if (pa->data.expn > pb->data.expn) {
    			pc->next = pa;
    			pc = pa;
    			pa = pa->next;
    		}
    		else if (pa->data.expn < pb->data.expn) {
    			pc->next = pb;
    			pc = pb;
    			pb = pb->next;
    		}
    		else {
    			sum = pa->data.coef + pb->data.coef;
    			if (fabs(sum) > 1e-6) {//系数之和不为零
    				pa->data.coef = sum;
    				pc->next = pa; pc = pa; pa = pa->next;
    				s = pb; pb = pb->next; free(s);
    			}
    			else {
    				s = pa; pa = pa->next; free(s);
    				s = pb; pb = pb->next; free(s);
    			}
    		}
    	}
    	pc->next = pa ? pa : pb;
    	free(w);
    }
    //多项式链表的相减 
    void SubPolyn(Linklist La, Linklist Lb, Linklist& Lc) {
    	Listnode* p;
    	Linklist w, v;
    	CopyPolyn(Lb, w);
    	CopyPolyn(La, v);
    	p = w->next;
    	while (p) {
    		p->data.coef = -p->data.coef;
    		p = p->next;
    	}
    	AddPolyn(v, w, Lc);
    }
    
    //销毁多项式
    void DesPolyn(Linklist La) {
    	Listnode* p;
    	p = La->next;
    	while (p) {
    		La->next = p->next;
    		free(p);
    		p = La->next;
    	}
    	free(La);
    	La ->next= NULL;
    }
    void Attach(float c, int e, Linklist* r) {
    	Linklist p;
    	p = (Linklist)malloc(sizeof(Listnode));
    	p->data.coef = c; p->data.expn = e;
    	p->next = NULL;
    	(*r)->next = p;
    	*r = p;
    }
    //多项式的乘积
    Linklist MultiPolyn(Linklist La, Linklist Lb) {
    	Linklist front, rear, t1, t2;
    	front = (Linklist)malloc(sizeof(Listnode));
    	front->next = NULL;
    	rear = front;
    	if (!La->next || !Lb->next)
    		return front;
    	t1 = La->next; t2 = Lb->next;
    	while (t2) {
    		Attach(t1->data.coef * t2->data.coef, t1->data.expn + t2->data.expn, &rear);
    		t2 = t2->next;
    	}
    	t1 = t1->next;
    	while (t1) {
    		t2 = Lb->next;
    		rear = front;
    		while (t2) {
    			int e;
    			float c;
    			c = t1->data.coef * t2->data.coef;
    			e = t1->data.expn + t2->data.expn;
    			while (rear->next && rear->next->data.expn > e)
    				rear = rear->next;
    			if (rear->next && rear->next->data.expn == e) {
    				if (rear->next->data.coef + c)
    					rear->next->data.coef += c;
    				else {
    					rear->next->data.coef = 0;
    					rear->next->data.expn = 0;
    				}
    			}
    			else {
    				Linklist t = (Linklist)malloc(sizeof(Listnode));
    				t->data.coef = c;
    				t->data.expn = e;
    				t->next = rear->next;
    				rear->next = t;
    				rear = t;
    			}
    			t2 = t2->next;
    		}
    		t1 = t1->next;
    	}
    	return front;
    }
    //多项式的n次幂
    Linklist ExpnPolyn(int n, Linklist L) {
    	int i;
    	Linklist p[n];
    	p[0] = L;
    	if (n == 1)
    		return L;
    	else {
    		for (i = 1; i < n; i++) {
    			p[i] = MultiPolyn(p[i - 1], L);
    		}
    	}
    	return p[n - 1];
    }
    //求多项式的值
    float Calculate(Linklist La, int n) {
    	Listnode* p;
    	float sum = 0.0;
    	p = La->next;
    	while (p) {
    		sum = sum + p->data.coef * pow(n, p->data.expn);
    		p = p->next;
    	}
    	return(sum);
    }
    //主函数
    int main() {//相加,相减 ,复制 ,相乘
    	Linklist La, Lb, Lc;
    	int n, e, flag, p, opt;
    	float m;
    	printf("\n_________________________________________\n");
    	printf("|  menu                                   |\n");
    	printf("|  1)输入,建立并打印多项式               |\n");
    	printf("|  2)多项式相加                           |\n");
    	printf("|  3)多项式相减                           |\n");
    	printf("|  4)复制多项式                           |\n");
    	printf("|  5)多项式相乘                           |\n");
    	printf("|  6)多项式的n次幂                        |\n");
    	printf("|  7)多项式求x=a的值                     |\n");
    	printf("|  8)销毁多项式                          |\n");
    	printf("|  0)退出                                 |\n");
    	printf("|_________________________________________|\n");
    	while (1) {
    		printf("选择要进行的操作:");
    		scanf("%d", &opt);
    		switch (opt) {
    		case 0:
    			exit;
    			break;
    		case 1:
    			printf("输入第一个多项式的项数:");
    			scanf("%d", &n);
    			printf("输入第一个多项式的每一项的系数,指数:\n");
    			CreatPolyn(La, n);
    			printf("第一个多项式为:");
    			PrintList(La);
    			printf("输入第二个多项式的项数:");
    			scanf("%d", &n);
    			printf("输入第二个多项式的每一项的系数,指数:\n");
    			CreatPolyn(Lb, n);
    			printf("第二个多项式为:");
    			PrintList(Lb);
    			break;
    		case 2:
    			AddPolyn(La, Lb, Lc);
    			printf("\n相加后的多项式为:");
    			PrintList(Lc);
    			printf("\n");
    			break;
    		case 3:
    			SubPolyn(La, Lb, Lc);
    			printf("相减后的多项式为:");
    			PrintList(Lc);
    			break;
    		case 4:
    			CopyPolyn(La, Lc);
    			printf("\n复制后得到的多项式为:");
    			PrintList(Lc);
    			break;
    		case 5:
    			Lc = MultiPolyn(La, Lb);
    			printf("\n相乘后的多项式为:");
    			PrintList(Lc);
    			break;
    		case 6:
    			printf("输入幂次:");
    			scanf("%d", &n);
    			printf("第1个或是第2个求幂次?");
    			scanf("%d", &p);
    			Lc = ExpnPolyn(n, p == 1 ? La : Lb);
    			printf("\n求幂次后的多项式为:");
    			PrintList(Lc);
    			break;
    		case 7:
    			printf("输入一个值如2进行运算:\n");
    			scanf("%d", &e);
    			printf("你要用哪个算?1还是2?:");
    			scanf("%d", &flag);
    			m = Calculate(flag == 1 ? La : Lb, e);
    			printf("%f", m);
    			break;
    		case 8:
    			printf("要销毁第1个还是第2个?");
    			scanf("%d", &opt);
    			if (opt == 1)
    				DesPolyn(La);
    			if (opt == 2)
    				DesPolyn(Lb);
    			printf("剩余的多项式为:");
    			PrintList(La); printf("\n");
    			PrintList(Lb);
    			break;
    		}
    	}
    	return 0;
    }
    
    (小声,乘法部分我有借鉴,只是期末了发着玩,难免有人需要,不图啥好处,如果原作者纠结的话请让我删除
    
    展开全文
  • 数据结构一元多项式运算的实现,输入两个一元多项式,如:A(x)=15+6x+9x7+3x18, B(x)=4x+5x6+16x7,求 A+B,A-B ,A*B。
  • PTA上面六道关于一元多项式运算器的六道例题的链表解法

    1. 一元多项式运算器——建立与输出

    通过键盘接收一组多项式的系数和指数,建立多项式(要求各项按指数升序排列),并按指定格式输出。

    输入格式:

    第一行输入一个正整数n,表示非零项个数。 第二行输入n对整数,每对形如(7,3),表示系数为7、指数为3的项。

    输出格式:

    按多项式形式输出,各项按指数升序排列,例如6+2X-7X^8

    输入样例:

    在这里给出一组输入。例如:

    4
    (6,0)(2,1)(-8,70)(4,150) 
    

    输出样例:

    在这里给出相应的输出。例如:

    6+2X-8X^70+4X^150
    //结尾无空行
    

    Answer:

    #include<stdio.h>
    #include<string.h>
    #include<stdlib.h>
    
    typedef struct node {
        int coef;
        int expn;
        struct node *next;
    }Node, *List;
    
    List Creat(int i) {
        List head;
        head = (List)malloc(sizeof(Node));
        List pre, pnew;
        pre = head;
        char a,b;
        for(int j = 0; j <= i; j++) {
            pnew = (List)malloc(sizeof(Node));
            scanf("%c%d,%d%c", &a, &pnew->coef, &pnew->expn, &b);
            pre -> next = pnew;
            pre = pnew;
        }
        return head;
    }
    
    void Print(List head) {
        List q = head->next->next;
        int flag = 1;
        if(!q) {
            putchar('0');
            printf("\n");
            return;
        }
        while(q) {
            if(q->coef > 0 && flag != 1) {
                putchar('+');
            }
            if(q->coef != 1 && q->coef != -1) {
                printf("%d", 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++;
        }
    }
    
    int main() {
        int i;
        scanf("%d", &i);
        List head;
        head = Creat(i);
        Print(head);
    }
    

    2. 一元多项式运算器——加法

    一元多项式运算器——加法(by Yan)实现两个一元多项式相加运算。

    输入格式:

    按2.3.1的格式,第一、二行输入一个加数;第三、四行输入另一个加数。

    输出格式:

    按2.3.1的格式,输出和多项式。

    输入样例:

    在这里给出一组输入。例如:

    5
    (6,0)(2,1)(8,7)(4,15)(3,18)
    3
    (7,1)(2,6)(-8,7)
    //结尾无空行
    

    输出样例:

    在这里给出相应的输出。例如:

    6+9X+2X^6+4X^15+3X^18
    //结尾无空行
    

    Answer:

    #include<stdio.h>
    #include<string.h>
    #include<stdlib.h>
    
    typedef struct node {
        int coef;
        int expn;
        struct node *next;
    }Node, *List;
    
    List Creat(int i) {
        List head;
        head = (List)malloc(sizeof(Node));
        List pre, pnew;
        pre = head;
        char a,b;
        for(int j = 0; j <= i; j++) {
            pnew = (List)malloc(sizeof(Node));
            scanf("%c%d,%d%c", &a, &pnew->coef, &pnew->expn, &b);
            pre -> next = pnew;
            pre = pnew;
        }
        return head;
    }
    
    void Print(List head) {
        List q = head->next->next;
        int flag = 1;
        if(!q) {
            putchar('0');
            printf("\n");
            return;
        }
        while(q) {
            if(q->coef > 0 && flag != 1) {
                putchar('+');
            }
            if(q->coef != 1 && q->coef != -1) {
                printf("%d", 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++;
        }
    }
    
    List Plus(List head1, List head2) {
        List pre = NULL, p = NULL, qre = NULL, q = NULL;
        pre = head1->next;
        p = head1->next->next;
        qre = head2->next;
        q = head2->next->next;
        int index = 1;
        while (p != NULL) {
            if (q == NULL) {
                return head1;
            }
            if (p->expn == q->expn) {
                p->coef = p->coef + q->coef;
                if (p->coef == 0) {
                    pre->next = p->next;
                    free(p);
                    if (pre) {
                        p = pre->next;
                    } else {
                        p = NULL;
                    }
                    qre->next = q->next;
                    free(q);
                    if (qre) {
                        q = qre->next;
                    } else {
                        q = NULL;
                    }
                } else {
                    pre = p;
                    p = p->next;
                    qre->next = q->next;
                    free(q);
                    if (qre) {
                        q = qre->next;
                    } else {
                        q = NULL;
                    }
                }
    //            printf("4\n");
            } else if (p->expn > q->expn) {//多项式1的项的指数大于多项式2的项时
                qre->next = q->next;
                q->next = p;
                pre->next = q;
                pre = q;
                q = qre->next;
    //            printf("3\n");
            } else if (q->expn > p->expn && p->next &&q->expn < (p->next)->expn) {//多项式2的项指数大小在多项式1的项与下一项中间时
    //            printf("1\n");
                qre->next = q->next;
                pre = p;
                p = p->next;
                q->next = p;
                pre->next = q;
                pre = q;
                q = qre->next;
            } else if (q->expn > p->expn && p->next && q->expn >= (p->next)->expn) {
                pre = p;
                p = p->next;
    //            printf("2\n");
            } else {
                pre = p;
                break;
            }
            index ++;
        }
        if (q) {//多项式2未计算完
            pre->next = q;
        }
        return head1;
    }
    
    int main() {
        int i1, i2;
        List head1, head2;
        scanf("%d", &i1);
        head1 = Creat(i1);
        scanf("%d", &i2);
        head2 = Creat(i2);
        List head = Plus(head1, head2);
        Print(head);
    }
    

    3. 一元多项式运算器——减法

    实现两个一元多项式相减运算。

    输入格式:

    按2.3.1的格式,第一、二行输入被减数;第三、四行输入减数。

    输出格式:

    按2.3.1的格式,输出差多项式。

    输入样例:

    在这里给出一组输入。例如:

    4 
    (6,0)(2,6)(8,7)(4,15) 
    5 
    (7,1)(2,6)(-8,7)(10,20)(16,30)
    //结尾无空行
    

    输出样例:

    在这里给出相应的输出。例如:

    6-7X+16X^7+4X^15-10X^20-16X^30
    //结尾无空行
    

    Answer:

    #include<stdio.h>
    #include<string.h>
    #include<stdlib.h>
    
    typedef struct node {
        int coef;
        int expn;
        struct node *next;
    }Node, *List;
    
    List Creat(int i) {
        List head;
        head = (List)malloc(sizeof(Node));
        List pre, pnew;
        pre = head;
        char a,b;
        for(int j = 0; j <= i; j++) {
            pnew = (List)malloc(sizeof(Node));
            scanf("%c%d,%d%c", &a, &pnew->coef, &pnew->expn, &b);
            pre -> next = pnew;
            pre = pnew;
        }
        return head;
    }
    
    void Print(List head) {
        List q = head->next->next;
        int flag = 1;
        if(!q) {
            putchar('0');
            printf("\n");
            return;
        }
        while(q) {
            if(q->coef > 0 && flag != 1) {
                putchar('+');
            }
            if(q->coef != 1 && q->coef != -1) {
                printf("%d", 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++;
        }
    }
    
    List Plus(List head1, List head2) {
        List pre = NULL, p = NULL, qre = NULL, q = NULL;
        pre = head1->next;
        p = head1->next->next;
        qre = head2->next;
        q = head2->next->next;
        int index = 1;
        while (p != NULL) {
            if (q == NULL) {
                return head1;
            }
            if (p->expn == q->expn) {
                p->coef = p->coef - q->coef;
                if (p->coef == 0) {
                    pre->next = p->next;
                    free(p);
                    if (pre) {
                        p = pre->next;
                    } else {
                        p = NULL;
                    }
                    qre->next = q->next;
                    free(q);
                    if (qre) {
                        q = qre->next;
                    } else {
                        q = NULL;
                    }
                } else {
                    pre = p;
                    p = p->next;
                    qre->next = q->next;
                    free(q);
                    if (qre) {
                        q = qre->next;
                    } else {
                        q = NULL;
                    }
                }
    //            printf("4\n");
            } else if (p->expn > q->expn) {//多项式1的项的指数大于多项式2的项时
                q->coef = -q->coef;
                qre->next = q->next;
                q->next = p;
                pre->next = q;
                pre = q;
                q = qre->next;
    //            printf("3\n");
            } else if (q->expn > p->expn && p->next &&q->expn < (p->next)->expn) {//多项式2的项指数大小在多项式1的项与下一项中间时
                q->coef = -q->coef;
    //            printf("1\n");
                qre->next = q->next;
                pre = p;
                p = p->next;
                q->next = p;
                pre->next = q;
                pre = q;
                q = qre->next;
            } else if (q->expn > p->expn && p->next && q->expn >= (p->next)->expn) {
                pre = p;
                p = p->next;
    //            printf("2\n");
            } else {
                pre = p;
                break;
            }
            index ++;
        }
        if (q) {//多项式2未计算完
            pre->next = q;
            List qq = q;
            while(qq) {
                qq->coef = - qq->coef;
                qq = qq->next;
            }
        }
        return head1;
    }
    
    int main() {
        int i1, i2;
        List head1, head2;
        scanf("%d", &i1);
        head1 = Creat(i1);
        scanf("%d", &i2);
        head2 = Creat(i2);
        List head = Plus(head1, head2);
        Print(head);
    }
    

    4. 一元多项式运算器——乘法

    实现两个一元多项式相乘运算。

    输入格式:

    按2.3.1的格式,第一、二行输入一个乘数;第三、四行输入另一个乘数。

    输出格式:

    按2.3.1的格式,输出积多项式。

    输入样例:

    在这里给出一组输入。例如:

    3 
    (6,0)(2,6)(8,7) 
    2 
    (7,1)(-8,7) 
    //结尾无空行
    

    输出样例:

    在这里给出相应的输出。例如:

    42X-34X^7+56X^8-16X^13-64X^14
    //结尾无空行
    

    Answer:

    #include<stdio.h>
    #include<string.h>
    #include<stdlib.h>
    
    typedef struct node {
        int coef;
        int expn;
        struct node *next;
    }Node, *List;
    
    List Creat(int i) {
        List head;
        head = (List)malloc(sizeof(Node));
        List pre, pnew;
        pre = head;
        char a,b;
        for(int j = 0; j <= i; j++) {
            pnew = (List)malloc(sizeof(Node));
            scanf("%c%d,%d%c", &a, &pnew->coef, &pnew->expn, &b);
            pre -> next = pnew;
            pre = pnew;
        }
        return head;
    }
    
    void Print(List head) {
        List q = head->next->next;
        int flag = 1;
        if(!q) {
            putchar('0');
            printf("\n");
            return;
        }
        while(q) {
            if(q->coef > 0 && flag != 1) {
                putchar('+');
            }
            if(q->coef != 1 && q->coef != -1) {
                printf("%d", 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++;
        }
    }
    
    List CopyList (List head) {
        List newHead = (List)malloc(sizeof(Node));
        newHead->next = NULL;
        List p = head->next;
        List p2 = newHead;
        while (p) {
            List new = (List)malloc(sizeof(Node));
            new->coef = p->coef;
            new->expn = p->expn;
            p2->next = new;
            p2 = new;
            p = p->next;
        }
        p2->next = NULL;
        return newHead;
    }
    
    List Plus(List head1, List head2) {
        List pre = NULL, p = NULL, qre = NULL, q = NULL;
        pre = head1->next;
        p = head1->next->next;
        qre = head2->next;
        q = head2->next->next;
        int index = 1;
        while (p != NULL) {
            if (q == NULL) {
                return head1;
            }
            if (p->expn == q->expn) {
                p->coef = p->coef + q->coef;
                if (p->coef == 0) {
                    pre->next = p->next;
                    free(p);
                    if (pre) {
                        p = pre->next;
                    } else {
                        p = NULL;
                    }
                    qre->next = q->next;
                    free(q);
                    if (qre) {
                        q = qre->next;
                    } else {
                        q = NULL;
                    }
                } else {
                    pre = p;
                    p = p->next;
                    qre->next = q->next;
                    free(q);
                    if (qre) {
                        q = qre->next;
                    } else {
                        q = NULL;
                    }
                }
    //            printf("4\n");
            } else if (p->expn > q->expn) {//多项式1的项的指数大于多项式2的项时
                qre->next = q->next;
                q->next = p;
                pre->next = q;
                pre = q;
                q = qre->next;
    //            printf("3\n");
            } else if (q->expn > p->expn && p->next &&q->expn < (p->next)->expn) {//多项式2的项指数大小在多项式1的项与下一项中间时
    //            printf("1\n");
                qre->next = q->next;
                pre = p;
                p = p->next;
                q->next = p;
                pre->next = q;
                pre = q;
                q = qre->next;
            } else if (q->expn > p->expn && p->next && q->expn >= (p->next)->expn) {
                pre = p;
                p = p->next;
    //            printf("2\n");
            } else {
                pre = p;
                break;
            }
            index ++;
        }
        if (q) {//多项式2未计算完
            pre->next = q;
        }
        return head1;
    }
    
    List Multiply (List head1, List head2) {
        List p2 = head2->next->next;
        List newHead = (List)malloc(sizeof(Node));
        List pp = (List)malloc(sizeof(Node));
        newHead->next = pp;
        pp->next = NULL;
        List p1;
        List head1Pre = CopyList(head1);
        List res = NULL;
        while (p2) {
            p1 = head1->next->next;
            while (p1) {
                p1->coef *= p2->coef;
                p1->expn += p2->expn;
                p1 = p1->next;
            }
            p2 = p2->next;
            res = Plus(head1, newHead);
            newHead = CopyList(head1);
            head1 = CopyList(head1Pre);
        }
        return res;
    }
    
    int main() {
        int i1, i2;
        List head1, head2;
        scanf("%d", &i1);
        head1 = Creat(i1);
        scanf("%d", &i2);
        head2 = Creat(i2);
        List head = Multiply(head1, head2);
        Print(head);
    }
    

    5. 一元多项式运算器——求值

    对于给定的X值,求出多项式的值。

    输入格式:

    第一、二行按2.3.1的格式,输入一个多项式; 第三行输入X的值。

    输出格式:

    输出多项式的值

    输入样例:

    在这里给出一组输入。例如:

    4 
    (6,0)(2,3)(8,5)(7,10) 
    2 
    //结尾无空行
    

    输出样例:

    在这里给出相应的输出。例如:

    7446
    //结尾无空行
    

    Answer:

    #include<stdio.h>
    #include<string.h>
    #include<stdlib.h>
    #include<math.h>
    
    typedef struct node {
        int coef;
        int expn;
        struct node *next;
    }Node, *List;
    
    List Creat(int i) {
        List head;
        head = (List)malloc(sizeof(Node));
        List pre, pnew;
        pre = head;
        char a,b;
        for(int j = 0; j <= i; j++) {
            pnew = (List)malloc(sizeof(Node));
            scanf("%c%d,%d%c", &a, &pnew->coef, &pnew->expn, &b);
            pre -> next = pnew;
            pre = pnew;
        }
        return head;
    }
    
    int Calculate(List head, int X) {
        List q = head->next->next;
        if(!q) {
            return 0;
        }
        int r = 0;
        while(q) {
            r += q->coef * pow(X, q->expn);
            q = q->next;
        }
        return r;
    }
    
    int main() {
        int i, X;
        scanf("%d", &i);
        List head;
        head = Creat(i);
        scanf("%d", &X);
        int result = Calculate(head, X);
        printf("%d\n", result);
    }
    

    6. 一元多项式运算器——求导

    实现多项式的求导运算

    输入格式:

    第一、二行按2.3.1的格式,输入一个多项式;

    输出格式:

    按2.3.1的格式,输出其导数多项式。

    输入样例:

    在这里给出一组输入。例如:

    4 
    (6,0)(2,1)(8,7)(4,15) 
    //结尾无空行
    

    输出样例:

    在这里给出相应的输出。例如:

    2+56X^6+60X^14
    //结尾无空行
    

    Answer:

    #include<stdio.h>
    #include<string.h>
    #include<stdlib.h>
    
    typedef struct node {
        int coef;
        int expn;
        struct node *next;
    }Node, *List;
    
    List Creat(int i) {
        List head;
        head = (List)malloc(sizeof(Node));
        List pre, pnew;
        pre = head;
        char a,b;
        for(int j = 0; j <= i; j++) {
            pnew = (List)malloc(sizeof(Node));
            scanf("%c%d,%d%c", &a, &pnew->coef, &pnew->expn, &b);
            pre -> next = pnew;
            pre = pnew;
        }
        return head;
    }
    
    void Print(List head) {
        List q = head->next->next;
        int flag = 1;
        if(!q) {
            putchar('0');
            printf("\n");
            return;
        }
        while(q) {
            if(q->coef > 0 && flag != 1) {
                putchar('+');
            }
            if(q->coef != 1 && q->coef != -1) {
                printf("%d", 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++;
        }
    }
    
    void Process(List head) {
        List pre = head->next;
        while (pre->next) {
            if (pre->next && pre->next->expn == 0) {
                pre->next = pre->next->next;
            }
            pre = pre->next;
            pre->coef *= pre->expn;
            pre->expn--;
        }
    }
    
    int main() {
        int i;
        scanf("%d", &i);
        List head;
        head = Creat(i);
        Process(head);
        Print(head);
    }
    

    大家不要把答案直接复制过去哦🤫,要自己思考一下呢!!!

    展开全文
  • 一元多项式运算程序

    2019-11-28 14:00:18
    前言:个人实现的一个用带头结点的链表实现的一元多项式运算程序。该程序支持多项式的创建、打印、加、减、乘以及取反操作。并且具备相应的用户操作菜单,用户提示菜单。其中针对多项式的各种操作已经模块化,并且每...

    前言:个人实现的一个用带头结点的链表实现的一元多项式运算程序。该程序支持多项式的创建、打印、加、减、乘以及取反操作。并且具备相应的用户操作菜单,用户提示菜单。其中针对多项式的各种操作已经模块化,并且每一个函数的功能都做了非常详细的注释。话不多说,开始讲解代码。

    存储结构

    链表结点结构体

    采用单链表的结点形式来存储多项式的每一个单项式。结构体中定义了单项式的系数和次数,以及指向下一个结点的指针。很容易理解。

    typedef struct LNode
    {
    	double coef;
    	int power;
    	struct LNode* next;
    }LNode;
    

    全局变量

    全局变量定义了一个指针数组,存放指向每一个多项式的头结点的指针,并且定义了一个counter,用来记录已创建的多项式个数。

    LNode* List[MaxLen];
    int counter = 0;
    

    整体框架

    运行过程

    主程序运行过程很简单,总体就分这三步:

    1. 输入多项式的数据
    2. 选择相应的功能
    3. 退出程序

    是不是很简单,主要原因在于我尽量将所有的单一功能放在了一个函数中,实现了最大程度上的模块化。也就可以使得我的主程序代码尽量简单明了,仅仅做的事情就是打印用户菜单。

    函数介绍

    所有head都是指头结点。

    链表(多项式)复制函数
    1. 定义新指针q指向待复制链表的开始结点,定义新指针p指向新链表的头结点;
    2. 创建新结点s,将q所指结点信息赋值给s,q后移;
    3. 将s插入新链表;
    4. 重复2、3直到q为空。
    LNode* CopyPolyn(LNode* head);
    
    链表(多项式)创建函数
    1. 定义遍历指针p指向开始结点,q指向p的前驱;
    2. 循环创建新结点,将输入的数据赋值给结点数据,然后插入链表;
    3. 结点按照次数从小到大的排列,所以插入链表时要做以下操作:
      1)、遵循次数从小到大插入
      2)、有同类项则合并
      3)、合并后若为0则删除结点
    void Creat(LNode* head, double iCoef, int iPower);
    
    数据加载函数

    依据用户的选择,程序执行两种数据加载函数的其中之一。其中前者为读取键盘输入,后者为读取txt文本文件输入。txt文本文件内容我会放在后文中。文本读取函数的具体执行过程用注释标注的非常详细,可以自行理解。

    void CreatPolynCin();
    void CreatPolynIfs();
    
    链表选择函数

    智能处理用户操作函数时输入的链表对象,既可以只操作一个链表,也可以操作多个链表。原理是借助一个数组来记录本次操作,用户希望操作的链表对象的头结点指针再全局LIst数组中的下标。

    int Choose(int cho[], int len);
    
    链表(多项式)打印函数

    调用后者函数,用户输入希望打印的多项式。然后传入相应链表的头结点打印相应的多项式。同时对于输出要做一下格式化的处理。

    void PrintPolyn(LNode* head);
    
    void ChoosePrint();
    
    链表(多项式)相加函数

    加法的原理:复制head1头结点链接的链表,给head头结点链接的链表,然后读取head2头结点链接的链表中每一个结点,就像创建链表一样与head中的每一个结点进行比较。有同类项则合并,无同类项则插入,有0项则删除。后者函数同理,智能处理用户输入的相加的多项式的对象。

    LNode* AddPolyn(LNode* head1, LNode* head2);
    void ChooseAdd();
    
    链表(多项式)取反函数

    用户选择要取反的对象,程序直接将其取反并打印输出。此函数最多取反一个函数

    void Opposite(LNode* head);
    void ChooseOpposite();
    
    链表(多项式)相减函数

    该函数实际上是一个减法选择函数,因为多个多项式连续相减可以转换为多个多项式连续相加。只需要将第一个多项式取反,再将最后结果取反即可得到相减的结果。

    void ChooseSubtract();
    
    链表(多项式)相乘函数

    同理,用户选择两个或多个要相乘的多项式,程序会自动处理。乘法的原理也很简单,同样的能化成加法来操作。在这里,我采用的是传统的,即我们平常笔算时用到的多项式乘法规则——项项相乘再相加。感兴趣的同学可以关注我的另一篇博客FFT应用于多项式乘法。这篇博客介绍了如何加快多项式乘法的算法,尤其在面对项数特别大时的情况,有着非常好的优化效果。但是对于项数一千以内的多项式乘法,逐个相乘的效果是要好一点的。

    LNode* MutPolyn(LNode* head1, LNode* head2);
    void ChooseMutiply();
    

    txt文本文件的内容

    1.9 2 2 5
    5 2 2.5 4
    -1.5 2 -2 5 2 4 5 2
    5.8 2 -2 4
    8 9 5 2 -1 2 -2 5

    其实这个你们完全可以自己写的,但是为了方便还是把我自己的,比较完整的测试数据放在这里,请自行取用吧。

    完整代码

    #include <cmath>
    #include <cstdio>
    #include <cstdlib>
    #include <fstream>
    #include <iostream>
    #include <windows.h>
    #define MaxLen 1024
    using namespace std;
    
    typedef struct LNode // 定义结点结构体
    {
    	double coef; // coefficient系数
    	int power; // 次数
    	struct LNode* next;
    }LNode;
    LNode* List[MaxLen]; // 结点指针数组,存放多项式的头指针
    int counter = 0; // 全局计数器,表示已存在多项式个数
    
    // 链表的复制
    LNode* CopyPolyn(LNode* head)
    {
    	/*
    	将head2所在多项式链表复制给head1
    	*/
    	LNode* q = head->next; // 一定要给下一个结点,否则头结点也会被复制进去
    	LNode* head1 = new LNode;
    	LNode* p = head1;
    
    	while (q != NULL)
    	{
    		LNode* s = new LNode;
    		s->coef = q->coef;
    		s->power = q->power;
    		p->next = s;
    		p = s;
    		q = q->next;
    	}
    	p->next = NULL;
    	return head1;
    }
    
    
    //创建结点的函数,提高可重用性
    void Creat(LNode* head, double iCoef, int iPower)
    {
    	LNode* p = head->next; // p是遍历指针
    	LNode* q = head; // q是p的前驱指针
    
    	while (1) // 该循环比较p指向的项的次数和输入次数的大小来判断操作
    	{
    		if (p == NULL || p->power > iPower)
    		{
    			/*
    			如果找到了比输入次数大的项,就新建一个结点插在该项之前
    			或者p指向了空,说明不存在比输入次数大的项,就在表尾插入新结点
    			p == NULL放在第一个if判断,否则在分支判断中会因为读取不到数据出问题
    			而且由短路逻辑可知,p == NULL判断为真后就不再判断后一个,同样不会出问题
    			*/
    			p = new LNode; // 直接令p指向一个新结点
    			p->coef = iCoef;
    			p->power = iPower;
    			p->next = q->next;
    			q->next = p;
    			break; // 退出循环,读取下一个输入
    		}
    		else if (p->power < iPower)
    		{ // 如果输入的次数更大则往后比较下一个结点
    			p = p->next;
    			q = q->next;
    		}
    		else if (p->power == iPower) // 如果次数一样就合并同类项
    		{
    			if (p->coef + iCoef == 0) // 如果系数相反就删除结点
    			{
    				q->next = p->next;
    				free(p); // 释放结点p的空间
    				p = q->next; // 继续让p指向q的后继,为空的话直接退出循环
    			}
    			else
    				p->coef += iCoef;
    			break; // 上述无论哪个操作执行完都要退出循环读取下一个输入
    		}
    	}
    }
    
    
    // 手动输入创建链表
    void CreatPolynCin()
    {
    	int inputPower; // 输入指数
    	double inputCoef; // 输入系数
    
    	LNode* head = new LNode; // 创建头结点
    	head->next = NULL; // 头结点指空表示空链表
    
    	cin.get(); // 过滤回车
    	printf("\t请按照“系数”“次数”的格式输入多项式的各项\n\t");
    
    	while (cin.peek() != EOF && cin.peek() != '\n') // 读到文件结尾或者回车时退出循环,按次数从小到大插入新的结点
    	{
    		cin >> inputCoef >> inputPower;
    		Creat(head, inputCoef, inputPower);
    	}
    	List[++counter] = head;
    	printf("\t成功创建了第%d个多项式\n\n", counter);
    }
    // 文本输入创建链表
    void CreatPolynIfs()
    {
    	int i = 0, j, len, flag; // flag标记是否为负数
    	double temp; // temp存储读到的数
    	double input[MaxLen]; // input数组保存多项式的项
    	char line[MaxLen]; // line字符串保存
        LNode* head;
    
    	printf("\t正在读取文件,请稍等:\n");
    	printf("\t加载中:");
    	while ((i += 10) < 100)
    	{
    		Sleep(300);
    		printf("*");
    	}
    	printf("加载完成!\n");
    	Sleep(1000);
    
    	ifstream file; // 定义输入文本
    	file.open("file.txt", ios::in); // 以读方式打开
    
    	while (file.getline(line, MaxLen)) // 逐行读取最大MaxLen个字符,读取到EOF返回-1
    	{
    		for (i = 0, len = 0; line[i] != '\0'; i++)
    		{
    			temp = 0, flag = 0;
    			if (line[i] >= '0' && line[i] <= '9')
    			{
    				if (line[i - 1] == '-') // 前面有负号的话标记一下
    					flag = 1;
    				for (j = i; line[j] != '\0' && line[j] != '.' && line[j] != ' '; j++) // 开始循环找完整的一个数
    				{ // 循环结束的条件是读到了字符串的终止符或读到了小数点或读到了空格
    					temp = temp * 10 + line[j] - '0';
    				}
    				if (line[j] == ' ') // 读到空格说明该数读完了,把j值赋给i跳过数字占用的字符
    					i = j - 1;
    				if (line[j] == '.') // 如果读到了小数点
    				{
    					double num = 0, point = 0; // num记录小数部分,point记录小数数位
    					for (j += 1; line[j] != '\0' && line[j] != ' '; j++) // j += 1表示挪到第一位小数
    					{ // 由于已经读到了小数点,所以循环结束的条件是读到了字符串的终止符或读到了空格
    						num = num * 10 + line[j] - '0';
    						point++;
    					}
    					temp += num / pow(10, point); // 将num转为小数加到temp上
    					i = j - 1;
    				}
    				flag ? input[len++] = -1 * temp : input[len++] = temp;
    			}
    		}
    
    		head = new LNode; // 每次都要让head指向新创建的结点,否则创建的所有链表都一样了
            head->next = NULL; // 头结点指空表示空链表
    		for (i = 0; i < len; i += 2) // 每两个相邻元素取出来作为一个项创建新结点
    			Creat(head, input[i], (int)input[i + 1]); // 别忘记转换类型,不用担心丢失精度,次数是整数
    		List[++counter] = head;
    		printf("\t成功创建了第%d个多项式\n\n", counter);
    	}
    }
    
    
    // 选择要操作的链表
    int Choose(int cho[], int len)
    {
    	while (cin.peek() != '\n')
    	{
    		cin >> cho[len];
    		if (cho[len] <= 0 || cho[len] > counter)
    		{
    			printf("\t您输入了不存在的%d号多项式!\n", cho[len]);
    			cin.sync(); // 如果不存在的多项式后仍然有输入,该函数将清空它们以免读取进了用户操作
    			return 0;
    		}
    		else
    			++len;
    	}
    	return len;
    }
    
    
    // 多项式打印
    void PrintPolyn(LNode* head)
    {
    	LNode* p = head->next;
    	while (p != NULL)
    	{
    		// 因为次数递增,因此次数为0的情况只可能发生在第一个,后面就无需判断次数是否为0
    		if (p->power == 0) // 常数项直接输出
    			printf("\t%.1lf", p->coef);
    		else
    		{
    			if (p->coef > 0 && p != head->next) // 如果系数大于0且不是首项
    				printf("+%.1lfx^%d", p->coef, p->power);
    			else if (p->coef < 0 && p != head->next) // 如果系数小于0且不是首项
    				printf("%.1lfx^%d", p->coef, p->power);
    			else // 如果是首项直接输出
    				printf("\t%.1lfx^%d", p->coef, p->power);
    		}
    		p = p->next;
    	}
    	printf("\n\n");
    }
    // 用户选择要打印的多项式
    void ChoosePrint()
    {
    	int snum[MaxLen] = { 0 }; // serial number序号
    	int serNum = 0;
    	cin.get();
    	printf("\t请输入您要打印的多项式的序号\n\t");
    	serNum = Choose(snum, serNum);
    
    	for (int i = 0; i < serNum; i++)
    	{
    		printf("\t第%d个多项式是:", snum[i]);
    		PrintPolyn(List[snum[i]]);
    	}
    	if (!serNum) return;
    }
    
    
    // 多项式相加
    LNode* AddPolyn(LNode* head1, LNode* head2)
    {
    	/*
    	加法原理:
    	复制head1链表给head
    	将head2中的每个结点读入head中
    	*/
    	LNode* p, * head; // head指向新链表的头结点
    	p = head2->next; // q指向第二个链表的开始结点
    	head = CopyPolyn(head1);
    
    	while (p != NULL)
    	{
    		Creat(head, p->coef, p->power);
    		p = p->next;
    	}
    	return head;
    }
    // 用户选择要相加的多项式
    void ChooseAdd()
    {
    	int add[MaxLen] = { 0 };
    	int addNum = 0; // 计录参与相加的多项式个数,标记是否输入错误的标志
    
    	cin.get();
    	printf("\t请输入参与相加的多项式序号\n\t");
    	addNum = Choose(add, addNum);
    	if (!addNum) return;
    
    	LNode* addHead = List[add[0]]; // 新建好和式链表头结点并初始化以便参与迭代
    	for (int i = 1; i < addNum; i++) // 逐个相加
    		addHead = AddPolyn(addHead, List[add[i]]); // 迭代
    	/*
    	如果相加后的结果只有一个常数,就要存入一个系数次数都为0的结点
    	而创建结点和相加函数要经常调用,因此不适合在它们内部放入这个操作
    	*/
    	if (addHead->next == NULL)
    	{
    		LNode* s = new LNode;
    		s->coef = 0;
    		s->power = 0;
    		s->next = NULL;
    		addHead->next = s;
    	}
    	List[++counter] = addHead;
    	printf("\t相加后的结果是(第%d个多项式):\n", counter);
    	PrintPolyn(addHead);
    }
    
    
    // 多项式取反
    void Opposite(LNode* head)
    {
    	LNode* p = head;
    	while (p != NULL)
    	{
    		p->coef *= -1;
    		p = p->next;
    	}
    }
    // 用户选择取反的多项式
    void ChooseOpposite()
    {
    	int oppoNum;
    	printf("\t请输入要取反的多项式序号\n\t");
    	cin >> oppoNum;
    	if (oppoNum > counter || oppoNum <= 0)
    		printf("\t您要取反的多项式不存在!\n");
    	else
    	{
    		Opposite(List[oppoNum]);
    		printf("\t取反后的结果是\n");
    		PrintPolyn(List[oppoNum]);
    	}
    }
    
    
    // 用户选择要相减的多项式并执行多项相减
    void ChooseSubtract()
    {
    	int sub[MaxLen] = { 0 };
    	int subNum = 0, flag = 0; // 计录参与相加的多项式的个数,标记是否输入错误的标志
    
    	cin.get();
    	printf("\t请输入参与相减的多项式序号\n\t");
    	subNum = Choose(sub, subNum);
    	if (!subNum) // 返回0表明输入序号异常,退出该操作
    		return;
    
    	LNode* subHead = CopyPolyn(List[sub[0]]);
    
    	Opposite(subHead); // 先取一次反
    	for (int i = 1; i < subNum; i++) // 逐个相加
    		subHead = AddPolyn(subHead, List[sub[i]]);
    	Opposite(subHead); // 对最后的结果再取一次反就得到最终结果
    
    	if (subHead->next == NULL)
    	{
    		LNode* s = new LNode;
    		s->coef = 0;
    		s->power = 0;
    		s->next = NULL;
    		subHead->next = s;
    	}
    	List[++counter] = subHead;
    	printf("\t相减后的结果是(第%d个多项式):\n", counter);
    	PrintPolyn(subHead);
    }
    
    
    // 多项式相乘
    LNode* MutPolyn(LNode* head1, LNode* head2)
    {
    	LNode* head = new LNode;
    	head->next = NULL;
    	LNode* p = head1->next;
    	LNode* q = head2->next;
    	while (p != NULL)
    	{
    		q = head2->next; // 每次循环都初始化q指向开始结点
    		while (q != NULL)
    		{
    			Creat(head, p->coef * q->coef, p->power + q->power);
    			q = q->next;
    		}
    		p = p->next;
    	}
    	return head;
    }
    // 用户选择要相乘的多项式
    void ChooseMutiply()
    {
    	int mut[10] = { 0 };
    	int mutNum = 0; // 计录参与相乘的多项式个数
    
    	cin.get();
    	cout << "\t请输入参与相乘的多项式序号\n\t";
    	mutNum = Choose(mut, mutNum);
    	if (!mutNum) return;
    
    	LNode* mutHead = List[mut[0]]; // 新建好和式链表头结点并初始化以便参与递归
    	for (int i = 1; i < mutNum; i++) // 逐个相加
    		mutHead = MutPolyn(mutHead, List[mut[i]]); // 迭代
    	List[++counter] = mutHead;
    
    	cout << "\t相加后的结果是(第" << counter << "个多项式):" << endl;
    	PrintPolyn(mutHead);
    }
    
    
    // 根据用户选择执行操作
    void Operation(int choice)
    {
    	switch (choice)
    	{
    	case 1:
    		printf("\t请问您要手动输入还是文本输入?\n");
    		printf("\t1.我不怕累!我要手动输入!\n");
    		printf("\t2.手太酸了,文本输入吧...\n\t");
    		int c;
    		cin >> c;
    		if (c == 1)
    			CreatPolynCin();
    		else
    			CreatPolynIfs();
    		break;
    	case 2:
    		ChoosePrint();
    		break;
    	case 3:
    		ChooseAdd();
    		break;
    	case 4:
    		ChooseSubtract();
    		break;
    	case 5:
    		ChooseMutiply();
    		break;
    	case 6:
    		ChooseOpposite();
    		break;
    	case 7:
    		printf("\t又在暗示我厂,7777777!\n");
    		exit(0);
    	case 8:
    		printf("\t我就知道您会瞎选,嘿嘿\n");
    		break;
    	default:
    		printf("\t抱歉该选项功能还未开发!请重新输入!\n");
    		break;
    	}
    }
    
    
    // 主函数入口
    int main(void)
    {
    	int choice;
    	printf("\t\t程序初始化成功!\n");
    	printf("\t\t  欢迎Ripe王!\n");
    
    	while (1)
    	{
    		printf("\t*******************************\n");
    		printf("\t***  请选择您要执行的操作   ***\n");
    		printf("\t***      1.创建多项式       ***\n");
    		printf("\t***      2.打印多项式       ***\n");
    		printf("\t***      3.多项式相加       ***\n");
    		printf("\t***      4.多项式相减       ***\n");
    		printf("\t***      5.多项式相乘       ***\n");
    		printf("\t***      6.多项式取反       ***\n");
    		printf("\t***       7.退出程序        ***\n");
    		printf("\t*******************************\n");
    		printf("\t");
    		cin >> choice;
    		Operation(choice);
    	}
    	return 0;
    }
    
    

    希望本篇博客能对你起到一点的帮助作用,也希望能动动小手点个赞,这样我才能知道,我的付出没有白费啦~~。

    展开全文
  • 两个一元多项式间的加减乘除 取反,支持同类项合并,排序从大到小
  • C语言数据结构:一元多项式运算

    千次阅读 2019-09-22 12:47:50
    一元多项式运算器的分析与实现 首先,需要解决一元多项式在计算机中的存储问题。 对于一元多项式: P = p0 + p1x + …+pnx^n 在计算机中,可以用一个线性表来表示: P = (p0,p1,…,pn), 但是对于形如 S(x) = 1 + 5x^...

    一元多项式运算器的分析与实现

    • 首先,需要解决一元多项式在计算机中的存储问题。对于一元多项式: P = p0 + p1x + …+pnx^n ;在计算机中,可以用一个线性表来表示: P = (p0,p1,…,pn), 但是对于形如 S(x) = 1 + 5x^10 000 -12x^15 000 的多项式,上面的方法显然不合适,会有很多的项系数为0,造成存储空间的浪费,因此只需要存储非0系数项。

    • 为了实现任意多项式的运算,考虑到运算时有较多的插入、删除操作,选择单链表作为存储结构比较方便,每个结点有三个域:系数、指数和指针。其数据结构如下所示:**

      typedef struct DuoXiangShi{
      	int xi_shu;  //系数
      	int zhi_shu; //指数
      	struct DuoXiangShi *next;  //指向下一个结点的指针
      	 
      }Polyn, *LinkPolyn;
      

    一、建立多项式

    • 通过键盘输入一组多项式的系数和指数,用尾插法建立一元多项式的链表。以输入系数0为结束标志,并约定建立一元多项式链表时,总是按指数从小到大的顺序排列。

      /*用尾插法创建链表*/
      LinkPolyn CreatePolyn(){
      	LinkPolyn head,p,tail;
      	 
      	float x;      //存储输入的系数 
      	int   e;      //存储输入的指数
      	head = (LinkPolyn)malloc(sizeof(Polyn));     //生成头结点
      	head->next = NULL;                   //生成空表
      	tail = head;
      	scanf("%d,%d",&x,&e);
      	while(x!=0)                  //当x=0时,多项式输入结束 
      	{
      		p = (LinkPolyn)malloc(sizeof(Polyn));
      		p->xi_shu = x;
      		p->zhi_shu = e;
      		tail->next = p;     //在表尾进行插入操作 
      		tail = p;           //tail始终指向表尾 
      		scanf("%f,%d",&x,&e);	
      	}
      	tail->next = NULL;          //将表中最后一个结点的next置为NULl 
      	
      	return head;
      } 
      

    二、输出多项式

    • 从单链表第一个元素开始,逐项读出系数和指数,按多项式的形式进行输出即可。

      /*打印多项式*/
      void PrintPolyn(LinkPolyn LA)
      {
      	LinkPolyn p = LA->next;      //LA有头结点,让p指向LA的第一元素结点
      	int flag = 1;
      	
      	if(!p)       //如果链表为空,没有项 
      	{
      		putchar('0');
      		printf("\n");
      		//return;
      	}
      	
      	while(p)
      	{
      		if(p->xi_shu > 0 && flag != 1)  putchar('+');
      		//if(p->xi_shu == 0) continue;
      		if(p->xi_shu != 1 && p->xi_shu != -1 && p->xi_shu != 0)
      		{
      			printf("%d",p->xi_shu);
      			if(p->zhi_shu == 1)
      			{
      				putchar('X');
      			}
      			else if(p->zhi_shu)
      			{
      				printf("X^%d",p->zhi_shu);
      			}
      			else               /*系数为1或系数为-1的情况*/
      			{
      				if(p->xi_shu == 1)
      				{
      					//如果指数为0
      					if(!p->zhi_shu)   putchar('1');
      					else if(p->zhi_shu == 1)  putchar('X');
      					else        printf("X^%d",p->zhi_shu); 
      				}
      				if(p->xi_shu == -1) 
      				{
      					//如果指数为0
      					if(!p->zhi_shu)   printf("-1");
      					else if(p->zhi_shu == 1)  printf("-X");
      					else        printf("-X^%d",p->zhi_shu);
      				}
      			}
      			
      			p = p->next;
      			flag++;
      		}
      		else{
      			p = p->next;
      		}
      	}
      	printf("\n");
      }
      

    三、两个多项式相加

    • 以单链表LA和LB分别表示两个一元多项式A和B,A+B的求和运算就等同于单链表的插入,设一个单链表LC来存放LA+LB的和。

      /*两个多项式相加------返回的还是一个多项式*/
      LinkPolyn AddPolyn(LinkPolyn LA,LinkPolyn LB)
      {
      	LinkPolyn pa = LA->next;      //指向LA的第一元素结点
      	LinkPolyn pb = LB->next;      //指向LB的第一元素结点	
      	
      	LinkPolyn LC,pc,qc;     //LC存储LA+LB
      	pc = (LinkPolyn)malloc(sizeof(struct DuoXiangShi));
      	pc->next = NULL;
      	LC = pc;        //保留原链的头指针 
      	
      	//当两个多项式均未扫描结束时 
      	while(pa != NULL && pb != NULL) 
      	{
      		qc = (LinkPolyn)malloc(sizeof(struct DuoXiangShi));
      		if(pa->zhi_shu < pb->zhi_shu)
      		{
      			qc->xi_shu = pa->xi_shu;
      			qc->zhi_shu = pa->zhi_shu;
      			pa = pa->next;
      		}
      		else if(pa->zhi_shu == pb->zhi_shu)
      		{
      			qc->xi_shu = pa->xi_shu + pb->xi_shu;
      			qc->zhi_shu = pa->zhi_shu;
      			pa = pa->next;
      			pb = pb->next; 
      		}
      		else
      		{
      			qc->xi_shu = pb->xi_shu;
      			qc->zhi_shu = pb->zhi_shu;
      			pb = pb->next; 
      		}
      		if(qc->xi_shu != 0)
      		{
      			qc->next = pc->next;
      			pc->next = qc;
      			pc = qc;
      		}
      		else free(qc);
      	} 
      	/*如果LA中有余项,将剩余项插入LC*/
      	while(pa != NULL)
      	{
      		qc = (LinkPolyn)malloc(sizeof(struct DuoXiangShi));
      		qc->xi_shu = pa->xi_shu;
      		qc->zhi_shu = pa->zhi_shu;
      		pa = pa->next;
      		qc->next = pc->next;
      		pc->next = qc;
      		pc = qc;
      	} 
      	/*如果LB中有余项,将剩余项插入LC*/
      	while(pb!= NULL)
      	{
      		qc = (LinkPolyn)malloc(sizeof(struct DuoXiangShi));
      		qc->xi_shu = pb->xi_shu;
      		qc->zhi_shu = pb->zhi_shu;
      		pb = pb->next;
      		qc->next = pc->next;
      		pc->next = qc;
      		pc = qc;
      	} 
      	return LC;	
      } 
      

    四、两个多项式相减

    • 将减数LB多项式的所有系数变为其相反数,然后使用两个多项式相加的思想进行处理。

      /*两个多项式相减------返回的还是一个多项式*/
      LinkPolyn SubstractPolyn(LinkPolyn LA,LinkPolyn LB)
      {
      	LinkPolyn b = LB;
      	LinkPolyn p = LB->next;
      	LinkPolyn LD;
      	while(p)
      	{
      		p->xi_shu *= -1;
      		p = p->next;
      	}
      	
      	LD = AddPolyn(LA,b);
      	
      	for(p = b->next; p ;p = p->next)
      	{
      		p->xi_shu *= -1;
      	}
      	return LD;
      } 
      
      

    五、多项式乘法

    • 多项式乘法类似于两个多项式相加,需要使用一个多项式的每一项和另一个多项式的每一项进行相乘,然后进行多项式相加操作

      /*多项式相乘*/
      LinkPolyn MultiplyPolyn(LinkPolyn LA,LinkPolyn LB)
      {
      	LinkPolyn pa = LA->next;
      	LinkPolyn pb = LB->next;
      	LinkPolyn LC,pc,qc;
      	LinkPolyn LD; 
      	LD = (LinkPolyn)malloc(sizeof(Polyn));
      	LD->next = NULL;        //建立一个空表 
      	
      	while(pa != NULL)
      	{
      		
      		pc = (LinkPolyn)malloc(sizeof(struct DuoXiangShi));
      		pc->next = NULL;
      		LC = pc; 
      		while(pb != NULL)
      		{
      			qc = (LinkPolyn)malloc(sizeof(struct DuoXiangShi));
      			qc->xi_shu = pa->xi_shu * pb->xi_shu;
      			qc->zhi_shu = pa->zhi_shu + pb->zhi_shu;
      			qc->next = pc->next;
      			pc->next = qc;
      			pc = qc; 
      			pb = pb->next; 
      		}
      		LD = AddPolyn(LD,LC);
      		pa = pa->next;
      		pb = LB->next;
      	}
      	return LD;
      } 
      

    六、求多项式的值

    • 需要输入变量x的值,然后进行求值运算

      /*多项式求值*/
      int EvaluatePolyn(LinkPolyn polyn,int x)
      {
      	LinkPolyn p = polyn->next;
      	int sum = 0;
      	while(p != 0)
      	{
      		sum += p->xi_shu*pow(x,p->zhi_shu);
      		p = p->next;
      	}
      	return sum;
      }
      

    七、多项式的导数

    • 需要根据导数公式对多项式的每一个结点求导,具体过程如下:多项式的当前结点指数为0,则其导数为0;当前结点指数不为0,则其导数的系数为当前结点指数乘以系数,指数为当前结点的指数减1。

      /*多项式的导数,返回值仍然为一个多项式*/
      LinkPolyn DaoPolyn(LinkPolyn polyn)
      {
      	LinkPolyn dao = polyn;
      	LinkPolyn p = polyn->next;
      	while(p!=NULL)
      	{
      		if(p->zhi_shu != 0)
      		{
      			p->xi_shu = p->zhi_shu * p->xi_shu;
      			p->zhi_shu = p->zhi_shu - 1;
      			p = p->next; 
      		}
      		else
      		{
      			p->xi_shu = 0;	
      			p = p->next;
      		}
      		
      	 
      	}
      	return dao;
      } 
      
    展开全文
  • 问题 B: DS-2.3.2 一元多项式运算器——加法(by Yan) 时间限制: 10 Sec 内存限制: 256 MB 提交: 1311 解决: 704 [提交][状态][讨论版] 题目描述 实现两个一元多项式相加运算。 输入 按2.3.1的格式,第一、二行输入...
  • 一元多项式运算c++版

    2018-07-20 21:03:49
    数据结构中经典题目,一元多项式的计算,运用c++实现一元多项式计算。
  • 功能:对多项式求值,求导,两多项式相加,相减,相乘等运算 作者:xuqg 时间:2019.9.19 */ #include<stdio.h> #include<stdlib.h> #include<math.h> typedef struct NodeType{ ...
  • 问题 D: DS-2.3.4 一元多项式运算器——乘法 时间限制: 10 Sec 内存限制: 256 MB 提交: 834 解决: 410 [提交][状态][讨论版] 题目描述 实现两个一元多项式相乘运算。 输入 按2.3.1的格式,第一、二行输入一个乘数;...
  • 实现两个一元多项式相减运算。 提示:当两个多项式相减为0时,要输出“0”。 输入 按2.3.1的格式,第一、二行输入被减数;第三、四行输入减数。 输出 按2.3.1的格式,输出差多项式。 样例输入 Copy 4 (6,0)(2,6)(8...
  • 运用一元多项式运算的基本法则,对一元多项式的加法、减法运算进行设计,并有人机交换界面
  • 数据结构 一元多项式运算

    千次阅读 2018-04-20 17:49:14
    链表的生成利用链表实现一元多项式的+、-、*运算,注意具体的思路是判断同类项,对其进行合并同类项,在乘法运算达到了O(n^3),可以优化的地方是先对结果链表C进行预处理,先复制这个链表给C,然后表C的操作过程就将...
  • 问题 A: DS-2.3.1 一元多项式运算器——建立与输出(by Yan) 时间限制: 10 Sec 内存限制: 256 MB 提交: 1694 解决: 922 [提交][状态][讨论版] 题目描述 通过键盘接收一组多项式的系数和指数,建立多项式(要求各项按...
  • 实现多项式的求导运算. 输入 第一、二行按2.3.1的格式,输入一个多项式; 输出 按2.3.1的格式,输出其导数多项式。 样例输入 4 (6,0)(2,1)(8,7)(4,15) 样例输出 2+56X^6+60X^14 #include<stdio.h> #include&...
  • 2)输入1,按回车键,如图5-2所示,先输入第一个多项式L1的项数,按回车键,然后依次输入每一项的系数和指数,按回车键,再输入第二个多项式L2,输入的多项式会自动保存到“duoxianshi.txt”中,若继续输入1,则再...
  • 一元多项式相加实验报告(C语言实现)
  • 数据结构的一元多项式的简单计算器。通过键盘接收一组多项式的系数和指数,建立多项式(要求各项按指数升序排列),并按指定格式输出。 加法,实现两个一元多项式相加运算。减法,乘法与求导运算
  • 实验题目:一元多项式计算器 实验内容: 设计线性表的动态或者静态链式存储结构,并实现一个一元多项式的计算器。 实验要求: 以动态或者静态链表存储一元多项式,在此基础上按要求完成对一元多项式运算。(为...
  • 利用链表:创建,复制,显示,求值,加法,减法,乘法,修改,求导,销毁,清空...
  • 实验一-一元多项式运算.doc
  • C语言实现一元多项式加法运算(链表)

    千次阅读 多人点赞 2019-10-05 21:26:25
    C语言实现一元多项式加法运算(链表) 完成如下操作: ①输入并建立一元稀疏多项式;(输入格式自定) 例如:4 - 12x3 + 123x5 - 80x10 ②输出所建立的一元多项式;(输出格式自定) 例如:12 - 3x + x3 + 230x12 ③...
  • 一元多项式运算.txt

    2020-06-08 14:43:53
    3. 一元多项式计算 功能要求: (1)能够按照指数降序排列建立并输出多项式; (2)能够完成两个多项式的相加、相减,并将结果输出;
  • 对于给定的X值,求出多项式的值。 输入 第一、二行按2.3.1的格式,输入一个多项式; 第三行输入X的值。 输出 输出多项式的值 样例输入 4 (6,0)(2,3)(8,5)(7,10) 2 样例输出 Copy 7446 #include<stdio.h> #...
  • C/C++实现一元多项式,包括源代码和实验报告。实现了一元多项式的创建,查看,相加和相乘。
  • 实习 1一元稀疏多项式计算器 一 需求分析 问题描述 设计一个一元稀疏多项式简单计算器 基本要求 一元稀疏多项式简单计算器的基本功能是 输入并建立多项式 (2) 输出多项式输出形式为整数序列 n, c 1, e 1, c 2, e 2, ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 5,575
精华内容 2,230
关键字:

一元多项式的运算