C语言课设，一元稀疏多项式计算（链式储存+文件读取输入+文件存储）

最新推荐文章于 2022-10-01 16:55:06 发布
最新推荐文章于 2022-10-01 16:55:06 发布
阅读量1k 收藏 4
点赞数 3
分类专栏： # C语言 课程设计 文章标签： c语言 链表 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dodamce/article/details/122316595
版权
这个博客介绍了一个使用C语言实现的多项式计算程序。程序包括多项式的创建、更新、插入、删除零项、加减乘运算以及升序和降序输出。用户可以输入系数和指数创建多项式，也可以从文件读取数据。计算完成后，用户可以选择不同的输出方式，如保存到文件或按特定顺序显示结果。
摘要由CSDN通过智能技术生成

学校C语言课设

文章目录

Calculate.h

#pragma once

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
typedef struct node* LIST;

struct Date//每个数字的系数和指数
{
    int c;//系数
    int n;//指数
};

struct node
{
    Date Val;
    LIST NEXT;
};

LIST UpDate(LIST Head)
{
    LIST Node = Head;
    while (Node != NULL)
    {
        if (Node->Val.c == 0)
        {
            if (Node == Head)
            {
                Head = Head->NEXT;
                free(Node);
                Node = Head;
            }
            else
            {
                LIST next = Node->NEXT;
                free(Node);
                Node = next;
            }
        }
        else
        {
            Node = Node->NEXT;
        }
    }
    return Head;
}

void Insert(int c, int n,LIST* head)
{
    LIST Node = *head;
    //找尾巴
    LIST BefNode = NULL;
    while (Node != NULL)
    {
        if (Node->Val.n == n)//合并同类项
        {
            Node->Val.c += c;
            break;
        }
        BefNode = Node;
        Node = Node->NEXT;
    }
    if (Node == NULL)//没有找到同类项
    {
        Node = (LIST)malloc(sizeof(struct node));
        Node->Val.c = c;
        Node->Val.n = n;
        Node->NEXT = NULL;
        if (BefNode != NULL)
        {
            BefNode->NEXT = Node;
        }
        else
        {
            *head = Node;
        }
    }
}

LIST UserInit()
{
    printf("输入系数和指数，以0 0结束\n");
    //输入系数和指数
    LIST head = NULL;
    int n, c;
    while (1)
    {
        scanf("%d%d", &c, &n);
        if (c == 0 && n == 0)
        {
            break;
        }
        else
        {
            Insert(c, n, &head);
        }
    }

    return UpDate(head);//去除链表中的0
}

void output(LIST head,FILE*fp)
{
    if (head == NULL)
    {
        fprintf(fp,"\n");
        return;
    }
    LIST P = head;
    if (!P) return;
    //输出第一个
    if (P->Val.c < 0)
        fprintf(fp,"-");
    if (P->Val.n == 0)
        fprintf(fp,"%d", abs(P->Val.c));
    else if (abs(P->Val.c) == 1)//判断系数
    {
        if (P->Val.n == 1)
            fprintf(fp,"x");
        else
            fprintf(fp,"x^%d", P->Val.n);
    }
    else
    {
        if (P->Val.n == 1)
            fprintf(fp,"%dx", abs(P->Val.c));
        else
            fprintf(fp,"%dx^%d", abs(P->Val.c), P->Val.n);
    }
    P = P->NEXT;
    //继续输出
    while (P)
    {
        if (P->Val.n == 0)
            fprintf(fp,"%c%d", P->Val.c > 0 ? '+' : '-', abs(P->Val.c));
        else if (abs(P->Val.c) == 1)
        {
            if (P->Val.n == 1)
                fprintf(fp,"%cx", P->Val.c > 0 ? '+' : '-');
            else
                fprintf(fp,"%cx^%d", P->Val.c > 0 ? '+' : '-', P->Val.n);
        }
        else
        {
            if (P->Val.n == 1)
                fprintf(fp,"%c%dx", P->Val.c > 0 ? '+' : '-', abs(P->Val.c));
            else
                fprintf(fp,"%c%dx^%d", P->Val.c > 0 ? '+' : '-', abs(P->Val.c), P->Val.n);
        }
        P = P->NEXT;
    }
    fprintf(fp,"\n");
}

LIST sub(LIST A, LIST B)
{
    LIST NodeB = B;
    LIST NodeA = A;
    LIST RET = NULL;
    while (NodeA != NULL)
    {
        Insert(NodeA->Val.c, NodeA->Val.n, &RET);
        NodeA = NodeA->NEXT;
    }
    while (NodeB != NULL)
    {
        Insert(-(NodeB->Val.c), NodeB->Val.n, &RET);
        NodeB = NodeB->NEXT;
    }
    return RET;
}

LIST add(LIST A, LIST B)
{
    LIST NodeB = B;
    LIST NodeA = A;
    LIST RET = NULL;
    while (NodeA != NULL)
    {
        Insert(NodeA->Val.c, NodeA->Val.n, &RET);
        NodeA = NodeA->NEXT;
    }
    while (NodeB != NULL)
    {
        Insert((NodeB->Val.c), NodeB->Val.n, &RET);
        NodeB = NodeB->NEXT;
    }
    return RET;
}

LIST mul(LIST A, LIST B)
{
    if (A == NULL || B == NULL)
    {
        return NULL;
    }
    else
    {
        LIST NodeB = B;
        LIST NodeA = A;
        LIST RET = NULL;
        while (NodeA != NULL)
        {
            while (NodeB != NULL)
            {
                Insert((NodeA->Val.c) * (NodeB->Val.c), (NodeA->Val.n) + (NodeB->Val.n), &RET);
                NodeB = NodeB->NEXT;
            }
            NodeA = NodeA->NEXT;
            NodeB = B;
        }
        return RET;
    }
}

void SortRET(LIST* RET,int flag)
{
    Date Array[30] = { 0 };//最大30项
    LIST Node = *RET;
    int Pos = 0;
    while (Node != NULL)
    {
        if (Pos >= 30)
        {
            printf("项数太大\n");
        }
        Array[Pos] = Node->Val;
        Pos++;
        Node = Node->NEXT;
    }
    if (flag == 1)//升序排序
    {
       for(int i=0;i<Pos;i++)
       {
           for (int j = 0; j < Pos - i - 1; j++)
           {
               if (Array[j].n > Array[j + 1].n)
               {
                   Date tmp = Array[j];
                   Array[j] = Array[j + 1];
                   Array[j + 1] = tmp;
               }
           }
       }
    }
    else
    {
        for (int i = 0; i < Pos; i++)
        {
            for (int j = 0; j < Pos - i - 1; j++)
            {
                if (Array[j].n < Array[j + 1].n)
                {
                    Date tmp = Array[j];
                    Array[j] = Array[j + 1];
                    Array[j + 1] = tmp;
                }
            }
        }
    }
    Node = *RET;
    for (int i = 0; i < Pos; i++)
    {
        Node->Val.c = Array[i].c;
        Node->Val.n = Array[i].n;
        Node = Node->NEXT;
    }
}

void Show(LIST*RET)
{
    while (1) {
        int flag;
        printf("请问你想升幂输出还是降幂输出-> \n\t1：升幂；\n\t2：降幂；\n\t3：all；\n\t4:升幂排列保存到文件中\n\t5：return\n");
        scanf("%d", &flag);
        switch (flag)
        {
        case 1:
            SortRET(RET,flag);
            break;
        case 2:
            SortRET(RET, flag);
            break;
        case 3:
            SortRET(RET, 1);
            output(*RET,stdout);
            SortRET(RET, 2);
            break;
        case 4:
        {
            SortRET(RET, 1);
            FILE* fp = fopen("RET.txt", "a");
            output(*RET, fp);
            printf("保存文件成功\n");
            break;
        }
        case 5:
            return;
        default:
            printf("输出错误\n");
            break;
        }
        output(*RET,stdout);
    }
}

void CalCul(LIST A,LIST B,LIST RET)//初始化
{
    if (A == NULL && B == NULL)
    {
        printf("都为空多项式，无法计算\n");
        return;
    }
    printf("A = "); output(A,stdout);
    printf("B = "); output(B,stdout);
    while (1) {
        int flag;
        printf("请选择操作命令-> \n \t1：加法；\n\t2：A - B；\n\t3：B - A；\n\t4：乘法；\n\t5：return\n");
        scanf("%d", &flag);
        switch (flag) {
        case 1:
            RET = UpDate(add(A, B));
            break;
        case 2:
            RET=UpDate(sub(A, B));
            break;
        case 3:
            RET = UpDate(sub(B, A));
            break;
        case 4:
            RET = UpDate(mul(A, B));
            break;
        case 5:
            return;
        default:
            printf("输入错误\n");
            break;
        }
        Show(&RET);
    }
}

void FushDate(char(*c)[10], int flag, LIST* A, LIST* B)
{
    int cNum = atoi(c[0]);
    int nNum = atoi(c[1]);
    if (flag == 0)
    {
        Insert(cNum, nNum, A);
    }
    else
    {
        Insert(cNum, nNum, B);
    }
}

void ReadFile(FILE* fp, LIST* A, LIST* B)
{
    char buff[300] = { 0 };
    int size=fread(buff, sizeof(char), sizeof(buff), fp);//数据读取到缓冲区中
    if (size > 300)
    {
        printf("缓冲区溢出\n");
        return;
    }
    int flag = 0;
    char c[2][10] = { 0 };
    int Chsize = 0;
    int Type = 0;//区分系数还是指数
    for (int i = 0;buff[i]!='\0'; i++)
    {
        if (buff[i] == '\n')
        {
            Type = 0;
            FushDate(c, flag, A, B);
            Chsize = 0;
            flag = 1;
            continue;
        }
        if (buff[i] >= '0' && buff[i] <= '9')
        {
            c[Type][Chsize] = buff[i];
            c[Type][Chsize + 1] = 0;
            Chsize++;
        }
        else if (buff[i] == '-')
        {
            if (i > 0 && buff[i - 1] >= '0' && buff[i - 1] <= '9')
            {
                Type = 0;
                FushDate(c, flag, A, B);
                Chsize = 0;
            }
            c[Type][Chsize] = '-';
            Chsize += 1;
        }
        else if (buff[i] == 'x')//找系数
        {
            if (Chsize == 0)
            {
                //系数为1
                c[Type][Chsize] = '1';
                c[Type][Chsize + 1] = 0;
                Chsize++;
            }
            if (buff[i - 1] == '-' || buff[i - 1] == '+')
            {
                c[Type][Chsize] = '1';
                Chsize += 1;
            }
        }
        else if (buff[i] == '^')//找指数
        {
            Type = 1;
            Chsize = 0;
        }
        else//'+'
        {
            if (i>0&&buff[i - 1] >= '0' && buff[i - 1] <= '9')
            {
                Type = 0;
                FushDate(c, flag, A, B);
                Chsize = 0;
            }
        }
    }
}

Calculate.cpp

#include"Calculator.h"

int main()
{
    int choce = 0;
    printf("是否从文件中读取要计算的数据？ 1.是 0.否\n");
    LIST A = NULL; LIST B = NULL; LIST RET = NULL;
    scanf("%d", &choce);
    if (choce == 0)
    {
        A=UserInit();
        B=UserInit();
    }
    else
    {
        printf("输入文件名\n");
        char FileName[32] = { 0 };
        scanf("%s", FileName);
        FILE* fp = fopen(FileName,"r");
        if (fp == NULL)
        {
            printf("文件打开失败\n");
        }
        ReadFile(fp, &A, &B);
        fclose(fp);
    }
    CalCul(A, B,RET);
    return 0;
}
NUC_Dodamce
关注
专栏目录
一元稀疏多项式计算器 数据结构课程设计
12-16
一元稀疏多项式简单计算器 问题描述如下： 一元稀疏多项式简单计算器的基本功能是： • 输入并建立多项式 :A(x）=7+3x+9x 8 +5x 17 ； B(x) =8x+22 x 7 -9x 8 ； 　　２．输出多项式，输出序列为： n c 1 ,e 1 c 2 ,e 2 ..... c n ,e n 其中n是多项式的项数，c i 和e i 分别是第i项的系数和指数，序列按指数降序排列 3．多项式A和B相加，建立多项式C=A+B，并输出相加的结果多项式C; 4．多项式A和B相减，建立多项式D=A-B，并输出相减的结果多项式D。
C语言 --- 一元稀疏多项式运算
weixin_46202067的博客
07-28 2938
C语言 --- 一元稀疏多项式运算题目要求功能设计结构体设计部分原代码功能实现截图 题目要求 输入并建立多项式； 输出多项式，输出形式为整数序列：n，c1，e1，c2，e2……cn，en，其中n是多项式的项数，ci，ei分别为第i项的系数和指数。序列按指数降序排列； 多项式A和B相加，建立多项式A+B，输出相加的多项式； 多项式A和B相减，建立多项式A-B，输出相减的多项式； 多项式A和B相乘，建立多项式A×B，输出相乘的多项式； 设计一个菜单，至少具有上述操作要求的基本功能。 功能设计 结构体设计
稀疏多项式加法c语言程序,一元稀疏多项式计算器C语言课程设计.docx
weixin_39945475的博客
05-22 1155
学号20142014-2015学年 第二学期《软件工程》课程设计报告题目：一元稀疏多项式计算器专业：计算机科学与技术班级：计算机科学与技术(2)班姓名：指导教师：成绩：TOC \o "1-3" \h \z \u HYPERLINK \l "_Toc435644060" 一、问题描述 PAGEREF _Toc435644060 \h 3HYPERLINK \l "_Toc435644061" 二、...
最详细的一元稀疏多项式计算器C语言实现
WRWEREWRET的博客
11-10 5237
1.程序设计思路 1.框架构想 本程序的设计目的旨在使用C语言设计一个一元稀疏多项式计算器，其具有计算器可视化界面，多项式的加减法计算功能和自然语言的输入输出方式的功能，计算器根据用户输入的多项式和指定的功能来进行计算，最后输出计算结果。 2.数据结构的选择 由于多项式是稀疏多项式，故不应该使用数组的形式存储多项式，而应该使用链表存储多项式。 typedef struct { double coef; //多项式系数 ...
数据结构——c语言 一元稀疏多项式
起当风萧的博客
04-11 4810
设计并验证以下算法：一元稀疏多项式计算器。 (1)设Pn(x)和Qm(x)分别为两个-元稀疏多项式，利用单链表存储Pn(x)和Qm(x)。 (2)从键盘输入一元多项式的信息，建立一元稀疏多项式Pn(x)和Qm(x),并输出。 (3)实现Pn(x)和Qm(x)相加，并输出两者的和Pn(x)+Qm(x)。 (4)实现Pn(x)和Qm(x)相减，并输出两者的差Pn(x)-Qm(x)。 (5)就地逆置两者的差Pn(x)-Qm(x)。 直接上代码： #include <stdio.h...
自-《C语言程序设计课程设计》题目 .pdf
07-12
- **数据结构**：使用带头指针的单链表表示一元稀疏多项式，适合处理具有大量零系数项的多项式，可以节省存储空间。 - **链表操作**：包括链表的创建、插入、遍历和合并，用于输入和输出多项式。 - **排序算法**...
C语言通用范例开发金典.part2.rar
08-31
范例1-7 多项式数组的表示 17 1.1.8 查找矩阵的马鞍点 19 范例1-8 查找矩阵的马鞍点 19 ∷相关函数：Get_Saddle函数 1.1.9 对角矩阵建立 21 范例1-9 对角矩阵建立 21 ∷相关函数：Store函数 1.1.10 三对角...
C语言通用范例开发金典.part1.rar
08-31
范例1-7 多项式数组的表示 17 1.1.8 查找矩阵的马鞍点 19 范例1-8 查找矩阵的马鞍点 19 ∷相关函数：Get_Saddle函数 1.1.9 对角矩阵建立 21 范例1-9 对角矩阵建立 21 ∷相关函数：Store函数 1.1.10 三对角...
数据结构（c语言版）代码
热门推荐
weixin_30814329的博客
01-07 3万+
第1章 绪论 文档中源码及测试数据存放目录：数据结构\▲课本算法实现\▲01 绪论 概述 第一章作为绪论，主要介绍了数据结构与算法中的一些基本概念和术语。对于这些概念术语，我个人不推崇死记硬背，记住了当然好，记不住也没关系，但是一定要做到完全理解。就算嘴上说不出来，心里也一定要明白这个过程的含义。 数据结构 数据(data)是对客观事物的符号表...
陈越、何钦铭《数据结构》第二讲线性结构 笔记
wtrnash的专栏
09-13 4706
《数据结构》第二讲 线性结构 2.1线性表及其实现 2.1.1引子：多项式表示 例：一元多项式及其运算 一元多项式: f(x) = a0 + a1x + a2x^2 + ……+ a(n-1) x ^ (n-1) + an x^n 主要运算：多项式相加、相减、相乘等 如何表示多项式？ 多项式的关键数据：多项式项数n，各项系数ai及指数i 方法1：顺序存储结构直接表示 数组各分量对应
C语言版数据结构，用单链表实现稀疏多项式的加法运算。
04-26
最近在学数据结构，讲完单链表后老师就布置了一个这样的答辩作业。代码附上啦，大多地方都添加了注释，要交作业的同学可以看一看。 实现要求： 1）两个一元稀疏多项式进行存储，并实现加法运算。 2）使用单链表的基本操作来实现多项式运算。 3）以一元多项式的标准形式显示结果。 4）设置合理输入格式。
一元稀疏多项式的计算（数据结构C++版）
qq_43589852的博客
12-21 5505
** 一元稀疏多项式的计算（数据结构C++版） ** [基本要求] （1）能够按照指数降序排列建立并输出多项式（升序只需稍微改动一下代码）； （2）能够完成两个多项式的相加、相减，并将结果输出； （3）以链式存储结构实现多项式。 [代码实现] //测试数据：2 1 4 3 5 2 78 1 3 2 4 3 6 4 #include<iostream> using namesp...
数据结构实验一元稀疏多项式
javaPGone的博客
05-18 537
算法实现 该程序共包含了一个接口、一个类和一个主类。Listter接口定义了顺序表中的方法名称。在类ArrayList中继承了该接口并实现了每一个方法。在Text类中实现一元稀疏多项式相加的方法，在主函数中构建实现多项式计算的过程。在完善创建多项式、加、减和乘的方法，最后在改写toString方法实现输出。 源码如下 import java.util.Scanner; public class Test { static ArrayList<Integer> Calculati
一元多项式
RunningBeef的博客
12-25 654
加法 减法 乘法 不定积分 求导 求值 数据由程序自动生成保存在文件中，多项式系数包含小数正 运算结果和时间消耗保存在文件中 #include <stdio.h> #include <stdlib.h>//多项式中数据按指数递增在文件中存储 #include <math.h> #include <time.h>//除了加法 将时间测试放在test函数里,别的直接放在原函数里 //初始多项式随机生成 和 多项式运算结果.
数据结构课程设计——用单链表存储多项式实现多项式相加（提供源码和报告）
爱吃雪糕的小布丁的博客
10-01 5776
在程序的主页面首先会提示输入第一个多项式的数据（最后输入0，0来结束数据输入），输完之后会把输入的数据按指数大小从小到大排列显示出来，接着提升输入第二个多项式的数据，并按指数大小从小到大显示出来，最后显示两个多项式 相加的结果。定义一个typedef struct Node2的结构体，结构体中包含有整型的指数、浮点型的系数和结构体指针next。另外定义结构体变量Node2和结构体指针PNode2，在后面的代码中会用到这两个来实现各函数的小功能。
[C语言]切比雪夫多项式，并写入到文件中
qq_44936245的博客
11-07 264
编写程序，输入n,x，并将0-n的所有Tn（x)值输出到文件tdat.txt中 #include <stdio.h> #include <stdlib.h> int main(){ int T(int n, int x); int x, n; int i; int rs; FILE *fp; printf("请输入n,x"); scanf("%d,%d", &n,&x); if((fp = fopen("D://tdat.txt","a+")) ==
利用单链表存储一元多项式_线性表的链式存储结构单链表
weixin_39873177的博客
11-24 492
线性表的链式存储结构-单链表说明公众号对话框里回复数字「002」，获取算法源码链表线性表的链式存储结构称为链表。因为线性表中每个结点有唯一的前驱结点和后继结点，所以在设计链式存储结构时，每个逻辑结点存储时单独存储为数据域，为了表示逻辑关系，增加指针域。单链表 1 认识单链表每个物理结点增加一个指向后继结点的指针域就是单链表。为了解决链表为空时，运算算法与非空链表的运算算法不同...
【数据结构】哈工大实验一：一元多项式（代碼以及報告）
清凌的博客
03-05 1798
代碼見最後的附錄。 一、 实验目的 写一个代码计算一元多项式 以链表存储一元多项式，在此基础上完成对多项式的代数操作。 1.能够输入多项式（可以按各项的任意输入顺序，建立按指数降幂排列的多项式）和输出多项式（按指数降幂排列）,以文件形式输入和输出，并显示。 2.能够计算多项式在某一点x=x0的值，其中x0是一个浮点型常量，返回结果为浮点数。 3.能够给出计算两个多项式加法、减法、乘...
C语言实现一元多项式链式存储计算
"这份资源是一份关于使用C语言实现一元多项式简单计算的课程设计报告，主要讨论了一元多项式的链式存储结构以及如何通过单链表实现多项式的加减运算。报告详细介绍了设计目标、方案确定、模块设计和程序流程，还包括...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

NUC_Dodamce

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

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

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

打赏作者

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

抵扣说明：

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

余额充值