【C语言X数据结构】用静态链表实现的多项式计算器，加减乘除求导求值，输入输出样样在行！（完整代码+注释）

最新推荐文章于 2023-10-26 15:19:56 发布
最新推荐文章于 2023-10-26 15:19:56 发布
阅读量935 收藏 9
点赞数 2
分类专栏： C语言程序设计 程序设计思路
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Li_Boxuan/article/details/109201219
版权

目录

实验要求

完整代码

逻辑设计

哈喽各位好，我是李博轩，一个刚转到计算机的大二学生。这个标题是随手打上去的，感觉还蛮顺口，就这样了。

这个学期在学【数据结构与算法】，而这是我面对的第一个实验题。因为大一不在计算机，编程能力落后于人，这个作业也花了很多时间和精力。总之，下面把题目要求和代码附上，希望得到各位的指点。

实验要求

        以动态或者静态链表存储一元多项式，在此基础上按要求完成对一元多项式的运算。（为保证多项式的值的准确性，多项式的系数可以用分数表示，涉及到两个分数相除时，结果也可以用分数表示。）

1. 能够输入多项式（可以按各项的任意输入顺序，建立按指数降幂排列的多项式）和输出多项式（按指数降幂排列）,以文件形式输入和输出，并显示。

2. 能够给出计算两个多项式加法、减法、乘法和除法运算的结果多项式，除法运算的结果包括商多项式和余数多项式。

3. 能够计算一元多项式的 k 阶导函数。

4. 能够计算多项式在某一点 x=x0 的值，其中 x0是一个浮点型常量，返回结果为浮点数。

5. 要求尽量减少乘法和除法运算中间结果的空间占用和结点频繁的分配与回收操作。（提示：利用循环链表结构或者可用空间表的思想，把循环链表表示的多项式返还给系统或者可用空间表，从而解决上述问题）。 

 完整代码

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#define MAXSIZE 4096
#define MAXLEN 256
typedef struct{
    int numerator;  //分子
    int denumerator;//分母
    int index; //指数
}elemtype;
typedef struct{
    elemtype val;
    int next;   //下一结点的指针
}LISTNODE;
LISTNODE SPACE[MAXSIZE];    //储存池
typedef int position, head; //表头和指针
head av = 0, L;
//初始化存储池
head load[MAXLEN] = {-1};
head save[MAXLEN] = {-1};
int loaded = 0; //是否已经加载
head cursor_s1 = -1;   //游标1
head cursor_s2 = -1;   //游标2
int cursor_save = 0; //保存用
int cursor_load = 0; //加载用
int number_load = 0;   //加载数量
int number_save = 0;   //结果数量
char cursor_menu = '9';    //菜单
//初始化菜单
void Init(){    //DONE!
    printf("正在初始化中...\n");
    //链接结点
    int i;
    for(i=0; i<MAXSIZE-1; i++){
        SPACE[i].val.numerator = 0;
        SPACE[i].val.denumerator = 1;
        SPACE[i].val.index = 0;
        SPACE[i].next = i+1;
    }
    //设定表尾
    SPACE[i].val.numerator = 0;
    SPACE[i].val.denumerator = 1;
    SPACE[i].val.index = 0;
    SPACE[i].next = -1;
    //表示可用线性表
    av = 0;
};
//获得可用空间
position GetNode(){ //DONE!!
    position p;
    if(SPACE[av].next==-1){
        p = -1;
        printf("可用空间为空！\n");
    }else{
        p = SPACE[av].next;
        SPACE[av].next = SPACE[p].next;
    }
    return p;
};
//回收可用空间
void FreeNode(position p){  //DONE!
    SPACE[p].next = SPACE[av].next;
    SPACE[av].next = p;
};
//创建链表
head Create(void){  //DONE!
    head p;
    if(SPACE[av].next==-1){
        p = -1;
        printf("创建链表时可用空间不足！\n");
    }
    else{
        p = GetNode();
        position q = GetNode();
        SPACE[p].next = q;
        SPACE[q].next = -1;
    }
    return p;
};
//链表插入
void Insert(elemtype x,position p){ //DONE!
    position q = GetNode();
    SPACE[q].val = x;
    SPACE[q].next = SPACE[p].next;
    SPACE[p].next = q;
};
//链表删除
void Delete(position p){    //DONE! （注：删除当前而非下一位）
    if(SPACE[p].next!=-1){
        position q = SPACE[p].next;
        SPACE[p].next = SPACE[q].next;
        SPACE[p].val = SPACE[q].val;
        FreeNode(q);
    }
};
//找到末尾元素
position End(head p){   //DONE!!
    position q = p;
    while(SPACE[SPACE[q].next].next!=-1){
        q = SPACE[q].next;
    }
    return q;
};
//找到起始元素
position First(head p){ //DONE!!
//清空链表
    return SPACE[p].next;
};
head Destory(head L){   //DONE!!
    position p =First(L);
    position q = p;
    while(SPACE[p].next!=-1){
        q = p;
        p = SPACE[p].next;
        FreeNode(q);
    }
};
//复制链表
head Copy(head L){  //DONE!!
    head newone = Create();
    position p =First(L);
    while(SPACE[p].next!=-1){
        Insert(SPACE[p].val,End(newone));
        p = SPACE[p].next;
    }
    return newone;
};

void MENU(void);    //陈列功能
void DISPLAY(void); //显示全部多项式
void SELECT(void);  //重新选择多项式
void COLLECT(void); //加载结果多项式
void SAVE(void); //保存输出多项式

head INPUT(void);
void LOAD(FILE* STR);
void SHOW(head L);
void LAST(void);

head PLUS(head L1,head L2);
head SUBTRACT(head L1,head L2);
head MULTIPLY(head L1,head L2);
void DIVIDE(head L1,head L2);
head DERIVALTIVE(head L);
double VALUE(head L,double x);
void CLEAR(head L);
head ZERO();

elemtype fractionPlus(elemtype a,elemtype b);
elemtype fractionSubtract(elemtype a,elemtype b);
elemtype fractionMultiply(elemtype a,elemtype b);
elemtype fractionDivide(elemtype a,elemtype b);
elemtype fractionGCD(elemtype x);

int main(){
    Init();
    MENU();
    FILE *str;
    str = fopen("INPUT.txt","r");
    if(str == NULL){
        printf("打开文件失败！");
        exit(0);
    }
    LOAD(str);
    DISPLAY();
    SELECT();
    while(cursor_menu!='0'){
        getchar();
        printf("请选择功能：");
        scanf("%c",&cursor_menu);
        switch (cursor_menu){
            case 'A':{
                DISPLAY();
            }break;
            case 'B':{
                SELECT();
            }break;
            case 'C':{
                head newone = INPUT();
                printf("输入为：\n");
                SHOW(newone);
                load[number_load] = newone;
                number_load ++;
                save[cursor_save] = newone;
                cursor_save++;
                number_load = cursor_load;
            }break;
            case 'D':{
                COLLECT();
                number_load = cursor_load;
            }break;
            case 'E':{
                SAVE();
            }break;
            case 'F':{
                LAST();
            }break;
            case 'H':{
                MENU();
            }break;
            case '1':{
                head newone = PLUS(load[cursor_s1],load[cursor_s2]);
                printf("和为：\n");
                SHOW(newone);
                save[cursor_save] = newone;
                cursor_save++;
            }break;
            case '2':{
                head newone = SUBTRACT(load[cursor_s1],load[cursor_s2]);
                printf("差为：\n");
                SHOW(newone);
                save[cursor_save] = newone;
                cursor_save++;
            }break;
            case '3':{
                head newone = MULTIPLY(load[cursor_s1],load[cursor_s2]);
                printf("积为：\n");
                SHOW(newone);
                save[cursor_save] = newone;
                cursor_save++;
            }break;
            case '4':{
                DIVIDE(load[cursor_s1],load[cursor_s2]);
            }break;
            case '5':{
                head newone = DERIVALTIVE(load[cursor_s1]);
                printf("导数为：\n");
                SHOW(newone);
                save[cursor_save] = newone;
                cursor_save++;
            }break;
            case '6':{
                printf("请输入求值的点：");
                double x;
                scanf("%lf",&x);
                VALUE(load[cursor_s1],x);
            }break;
        }
    }
    printf("正在关机...\n");
    fclose(str);
}
head INPUT(void){   //DONE!!
    printf("请按照“系数分子/系数分母 指数”的顺序输入多项式，分母为0结束：\n");
    printf("例：-1/2 2 3/1 4 4/1 3 3/2 5 1/0 1\n");
    int fz, fm, zh;
    head newone = Create();
    int count = 0;
    while(1){
        scanf("%d/%d %d",&fz,&fm,&zh);
        if(fm == 0) break;
        count += 1;
        elemtype x;
        x.numerator = fz;
        x.denumerator = fm;
        x.index = zh;
        Insert(x,End(newone));
    }
    for(int i=0; i<count-1;i++){
        position p = SPACE[newone].next;
        for(int j=0; j<count-1-i;j++){
            if((SPACE[p].val.index)<(SPACE[SPACE[p].next].val.index)){
                elemtype temp = SPACE[p].val;
                SPACE[p].val = SPACE[SPACE[p].next].val;
                SPACE[SPACE[p].next].val = temp;
            }
            p = SPACE[p].next;
        }
    }
    CLEAR(newone);
    return newone;
}
void LOAD(FILE* STR){   //DONE!!
    if(loaded == 0){
        printf("正在从文件中读取多项式...\n");
        fscanf(STR,"%d",&number_load);
        printf("读取到%d个多项式!!\n",number_load);
        cursor_load = 0;
        int fz, fm, zh;
        while(cursor_load < number_load && number_load < MAXLEN){
            head newone = Create();
            int count = 0;
                while(1){
                    fscanf(STR,"%d/%d %d",&fz,&fm,&zh);
                    if(fm == 0) break;
                    elemtype x;
                    x.numerator = fz;
                    x.denumerator = fm;
                    x.index = zh;
                    Insert(x,End(newone));
                    count ++;
                }
                for(int i=0; i<count-1;i++){
                    position p = First(newone);
                    for(int j=0; j<count-1-i;j++){
                        if((SPACE[p].val.index)<(SPACE[SPACE[p].next].val.index)){
                            elemtype temp = SPACE[p].val;
                            SPACE[p].val = SPACE[SPACE[p].next].val;
                            SPACE[SPACE[p].next].val = temp;
                        }
                        p = SPACE[p].next;
                    }
                }
            load[cursor_load] = newone;
            cursor_load ++;
        }
        loaded = 1;
        return;
    }
    else printf("多项式已加载！\n");
}
void SHOW(head L){  //DONE!!
    position p = First(L);
    printf("\t\t");
    while(SPACE[p].next!=-1){
        if(SPACE[p].val.index==0){
            printf("(%d/%d)",SPACE[p].val.numerator,SPACE[p].val.denumerator);
        }else{
            printf("(%d/%d) x^%d",SPACE[p].val.numerator,SPACE[p].val.denumerator,SPACE[p].val.index);
        }
        if(SPACE[SPACE[p].next].next!=-1) printf(" + ");
        p = SPACE[p].next;
    }
    printf("\n");
}
head PLUS(head L1,head L2){ //DONE!!
    head newone = Create();
    head List1 = Copy(L1);
    head List2 = Copy(L2);
    //SHOW(List1);
    //SHOW(List2);
    position p1 = First(List1);
    position p2 = First(List2);
    while(SPACE[p1].next!=-1&&SPACE[p2].next!=-1){
        if(SPACE[p1].val.index>SPACE[p2].val.index){
            elemtype x = SPACE[p1].val;
            Insert(x,End(newone));
            p1 = SPACE[p1].next;
        }
        else if(SPACE[p1].val.index<SPACE[p2].val.index){
            elemtype x = SPACE[p2].val;
            Insert(x,End(newone));
            p2 = SPACE[p2].next;
        }
        else if(SPACE[p1].val.index==SPACE[p2].val.index){
            elemtype x = fractionPlus(SPACE[p1].val,SPACE[p2].val);
            Insert(x,End(newone));
            p1 = SPACE[p1].next;
            p2 = SPACE[p2].next;
        }
        else{
            printf("ERROR WHEN PLUS!!\n");
        }
    }
    SPACE[End(newone)].next = (SPACE[p1].next==-1)?p2:p1;
    CLEAR(newone);
    return newone;
}
head SUBTRACT(head L1,head L2){ //DONE!!
    head newone = Create();
    head List1 = Copy(L1);
    head List2 = Copy(L2);
    //SHOW(List1);
    //SHOW(List2);
    position p1 = First(List1);
    position p2 = First(List2);
    while(SPACE[p1].next!=-1&&SPACE[p2].next!=-1){
        elemtype x = SPACE[p1].val;
        elemtype y = SPACE[p2].val;
        if(SPACE[p1].val.index>SPACE[p2].val.index){
            Insert(x,End(newone));
            p1 = SPACE[p1].next;
        }
        else if(SPACE[p1].val.index<SPACE[p2].val.index){
            y.numerator *= -1;
            Insert(y,End(newone));
            p2 = SPACE[p2].next;
        }
        else{
            elemtype z = fractionSubtract(x,y);
            Insert(z,End(newone));
            p1 = SPACE[p1].next;
            p2 = SPACE[p2].next;
        }
    }
    if(SPACE[p2].next==-1){
        SPACE[End(newone)].next = p1;
        CLEAR(newone);
        return newone;
    }
    while(SPACE[p2].next!=-1){
        elemtype y = SPACE[p2].val;
        y.numerator *= -1;
        Insert(y,End(newone));
        p2 = SPACE[p2].next;
    }
    CLEAR(newone);
    return newone;
}
head MULTIPLY(head L1,head L2){ //DONE!!
    position p = First(L1); int s1 = SPACE[p].val.index;
    position q = First(L2); int s2 = SPACE[q].val.index;
    head* arrL = (head*) malloc(sizeof(position)*(s1+1)*(s2+1));
    int count = 0;
    while(SPACE[p].next!=-1){
        arrL[count] = Create();
        q = First(L2);
        while(SPACE[q].next!=-1){
            elemtype newnode = fractionMultiply(SPACE[p].val,SPACE[q].val);
            Insert(newnode,End(arrL[count]));
            q = SPACE[q].next;
            //printf("q动了一下！");
        }
        //printf("p动了一下！");
        count ++;
        p = SPACE[p].next;
    }
    //printf("需要相加的有%d个式子:\n",count);
    head* L = (head*) malloc(sizeof(position)*(s1+s2+1));
    L[0] = ZERO();
    for(int i=0; i<count; i++){
        L[i+1] = Create();
        //printf("第%d个式子为：",i+1);
        //SHOW(arrL[i]);
        //SHOW(L[i]);
        L[i+1] = PLUS(L[i],arrL[i]);
        //printf("第%d个he式为：",i+1);
        //SHOW(L[i+1]);
    }
    free(arrL);     arrL = NULL;
    CLEAR(L[count]);
    return L[count];
}
elemtype fractionMultiply(elemtype a,elemtype b){ //DONE!!
    elemtype x;
    x.index = a.index + b.index;
    x.numerator = a.numerator * b.numerator;
    x.denumerator = a.denumerator * b.denumerator;
    return fractionGCD(x);
}
elemtype fractionPlus(elemtype a,elemtype b){
    if(a.index!=b.index){
        printf("指数不同无法相加！\n");
        return a;
    }
    int fz1 = a.numerator;  int fm1 = a.denumerator;
    int fz2 = b.numerator;  int fm2 = b.denumerator;
    int fz = fz1*fm2 + fz2*fm1; int fm = fm1*fm2;
    elemtype x;
    x.numerator = fz;
    x.denumerator = fm;
    x.index = a.index;
    return fractionGCD(x);
}
elemtype fractionSubtract(elemtype a,elemtype b){
    if(a.index!=b.index){
        printf("指数不同无法相减！\n");
        return a;
    }
    int fz1 = a.numerator;  int fm1 = a.denumerator;
    int fz2 = b.numerator;  int fm2 = b.denumerator;
    int fz = fz1*fm2 - fz2*fm1; int fm = fm1*fm2;
    elemtype x;
    x.numerator = fz;
    x.denumerator = fm;
    x.index = a.index;
    return fractionGCD(x);
}
elemtype fractionGCD(elemtype x){   //DONE!!
    int fz = abs(x.numerator);
    int fm = abs(x.denumerator);
    if(fm==0){
        printf("出现分母为零!\n");
        return x;
    }
    if(fz==0){
        x.denumerator = 1;
        return x;
    }
    int GCD = fz>fm?fm:fz;
    while(GCD>1){
        if((fz%GCD==0)&&(fm%GCD==0)){
            break;
        }
        GCD--;
    }
    fm = x.denumerator/GCD;
    fz = x.numerator/GCD;
    elemtype xgcd;
    xgcd.numerator = fz;
    xgcd.denumerator = fm;
    xgcd.index = x.index;
    return xgcd;
}
head DERIVALTIVE(head L){
    head newone = Create();
    position p = First(L);
    while(SPACE[p].next!=-1){
        elemtype x;
        if(SPACE[p].val.index==0){
            x.numerator = 0;
        }else{
            x.numerator = SPACE[p].val.numerator * SPACE[p].val.index;
        }
        x.denumerator = SPACE[p].val.denumerator;
        x.index = SPACE[p].val.index - 1;
        Insert(fractionGCD(x),End(newone));
        p = SPACE[p].next;
    }
    CLEAR(newone);
    return newone;
}
double VALUE(head L,double x){
    double ans = 0;
    position p = First(L);
    while(SPACE[p].next!=-1){
        ans += SPACE[p].val.numerator*1.0/SPACE[p].val.denumerator*1.0*pow(x,SPACE[p].val.index);
        p = SPACE[p].next;
    }
    printf("该多项式在%.2lf处的值为：%.2f\n",x,ans);
    return ans;
}
void DIVIDE(head L1,head L2){
    //多项式相除->获得商元素->获得余数多项式->余数多项式作为被除数
    //直到被除数的最高次数小于除数的最高次数
    const head divide = Copy(L2); //divide_除数
    head bedivided = Copy(L1);//一直在变化的被除数
    head quotient = ZERO();//创建商多项式
    head sub_bedivided = Create();
    sub_bedivided = bedivided;//创建一个被减元素
    while(SPACE[SPACE[sub_bedivided].next].val.index>=SPACE[SPACE[divide].next].val.index){
        bedivided = sub_bedivided;
        //新的余数作为新的被除数
        elemtype part = fractionDivide(SPACE[First(bedivided)].val,SPACE[First(divide)].val);
        //计算商元素
        CLEAR(quotient);
        //商元素插入商多项式中
        head quotient_part = Create();
        Insert(part,End(quotient_part));
        quotient = PLUS(quotient_part,quotient);
            //printf("商元素为:\t");
            //SHOW(quotient_part);
        //创建一个商元素多项式
        head mul_divide = MULTIPLY(quotient_part,L2);
            //printf("乘过的为:\t");
            //SHOW(mul_divide);
        sub_bedivided = SUBTRACT(bedivided,mul_divide);
        //获取余数
        CLEAR(sub_bedivided);
            //printf("余数为:\t");
            //SHOW(sub_bedivided);
        Destory(quotient_part);
    }
    printf("商为：\n");
    SHOW(quotient);
    save[cursor_save] = quotient;
    cursor_save++;
    printf("余数为：\n");
    SHOW(sub_bedivided);
    save[cursor_save] = sub_bedivided;
    cursor_save++;
}
elemtype fractionDivide(elemtype a,elemtype b){
    if(a.index<b.index){
        printf("被除多项数次数小于除数多项式，不能再除！\n");
        return a;
    }
    int fz1 = a.numerator;  int fm1 = a.denumerator;
    int fz2 = b.numerator;  int fm2 = b.denumerator;
    elemtype x;
    x.index = a.index-b.index;
    x.numerator = fz1 * fm2;
    x.denumerator = fz2 * fm1;
    x = fractionGCD(x);
    return x;
}
head ZERO(void){
    head newone = Create();
    elemtype x;
    x.numerator = 0;
    x.denumerator = 1;
    x.index = 0;
    Insert(x,End(newone));
    return newone;
}
void CLEAR(head L){
    position p = First(L);
    while(SPACE[p].next!=-1){
        if(SPACE[p].val.numerator==0){
            Delete(p);
        }else{
            p = SPACE[p].next;
        }
    }
}
void MENU(void){    //DONE!
    printf("------欢迎使用一元多项式计算器------\n");
    printf("将读入多项式，请选择功能：\n");
    printf("A->显示所有\t");
    printf("B->重新选中\t");
    printf("C->键盘输入\t");
    printf("D->加载结果\t");
    printf("E->保存结果\t");
    printf("F->选中最新\t");
    printf("H->帮助\n");
    printf("0->退出\t\t");
    printf("1->求和\t\t");
    printf("2->做差\t\t");
    printf("3->乘积\t\t");
    printf("4->相除\t\t");
    printf("5->求导\t\t");
    printf("6->求值\n");
}
void DISPLAY(void){
    printf("初始输入多项式：\n");
    for(int i=0; i<number_load; i++){
        printf("编号：%d-->\n",i);
        SHOW(load[i]);
    }
    printf("结果多项式：\n");
    for(int i=0; i<cursor_save; i++){
        printf("编号：%d-->\n",i);
        SHOW(save[i]);
    }
}
void SELECT(void){
    printf("按次序选择两个多项式：");
    scanf("%d %d",&cursor_s1,&cursor_s2);
    if (cursor_s1>0){
        if(cursor_s1>number_load||cursor_s2>number_load){
            printf("数字过大！\n");
            return;
        }
        printf("你选中了：\n");
        printf("第一个->\n");
        SHOW(load[cursor_s1]);
        printf("第二个->\n");
        SHOW(load[cursor_s2]);
    }
}
void COLLECT(void){
    fflush(stdin);
    printf("选择结果多项式：\n");
    for(int i=0; i<cursor_save; i++){
        printf("编号：%d-->\n",i);
        SHOW(save[i]);
    }
    int s;
    scanf("%d",&s);
    if(0<=s&&s<=cursor_save){
            printf("载入输出编号%d-->",s);
            load[cursor_load] = save[s];
            printf("输入编号%d！",cursor_load);
            cursor_load++;
    }
}
void SAVE(void){
    FILE* PUT;
    PUT = fopen("OUTPUT.txt","w");
    if(PUT == NULL){
        printf("保存失败！！\n");
        return;
    }
    printf("正在储存数据...\n");
    number_save = cursor_save;
    fprintf(PUT,"%d\n",number_save);
    for(int i=0; i<number_save; i++){
            position p = First(save[i]);
            while(SPACE[p].next!=-1){
                fprintf(PUT,"%d/%d %d ",SPACE[p].val.numerator,SPACE[p].val.denumerator,SPACE[p].val.index);
                p = SPACE[p].next;
            }
            fprintf(PUT,"1/0 1 \n");
    }
    fclose(PUT);
    printf("储存完毕！！正在返回计算器...\n");
    MENU();
}
void LAST(void){
    load[cursor_load] = save[cursor_save-1];
    printf("载入最新结果！\t");
    cursor_s1 = cursor_load;
    cursor_load++;
}

 

逻辑设计

主程序流程图

程序模块间的调用关系

 

 

 

Li_Boxuan
关注
  • 2
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
crc码生成多项式怎么算出来的_CRC校验源码分析
weixin_33374585的博客
12-10 1万+
这两天做项目，需要用到 CRC 校验。以前没搞过这东东，以为挺简单的。结果看看别人提供的汇编源程序，居然看不懂。花了两天时间研究了一下 CRC 校验，希望我写的这点东西能够帮助和我有同样困惑的朋友节省点时间。先是在网上下了一堆乱七八遭的资料下来，感觉都是一个模样，全都是从 CRC 的数学原理开始，一长串的表达式看的我头晕。第一次接触还真难以理解。这些东西不想在这里讲，随便找一下都是一大把。我想根据...
【CRC循环冗余校验-2】crc多项式及校验原理
幻蜗的笔记
09-27 9321
CRC多项式是为了生成一个除数，这个除数是模二运算的除数 示例：, 多项式生成的二进制序列位数是最高次幂加一，即6位，即从第0位开始到第5位，多项式中为0的位已经省略，原式为：（0次幂为1），幂次数也即其位置，即：100101 如上，生成的二进制序列即为crc检验用到的除数，而crc校验码即数据补0后除（模二运算除）以这个除数后的余数，检验码位数比除数少一位，余数不足的位用0补足，数据补0即在原始数据后加上除数减一个0. 示例：原始数据：10110011, 多项式： 多项式生成除...
CRC校验(1)：CRC原理、计算例子和最优多项式的选择
主要分享硬件、嵌入式软件部分知识
06-13 6875
CRC校验在做项目的过程中经常会使用到，在我上大学的时候有浅浅地理解这个计算的过程，后面工作了就是直接用NXP SDK中写的软件CRC的代码。说实话，我看不懂这简简单单的几行CRC-32查表算法，但我不希望我只是会用这些函数，而是要理解其中的原理。所以我开始写这一系列的博客深入地研究和理解常见的一些算法，希望能有所收获。对于现在的CPU来说，大多都在硬件上实现了CRC校验，但我想从软件上来实现CRC32的查表算法，包括表格的生成和CRC的计算。
CRC校验多项式
Owen_Liangcheng的博客
04-28 1万+
循环冗余校验码（CRC） 循环冗余校验码（CRC）的基本原理是：在K位信息码后再拼接R位的校验码，整个编码长度为N位，因此，这种编码又叫（N，K）码。对于一个给定的（N，K）码，可以证明存在一个最高次幂为N-K=R的多项式G(x)。根据G(x)可以生成K位信息的校验码，而G(x)叫做这个CRC码的生成多项式。 校验码的具体生成过程为：假设发送信息用信息多项式C(X)表示，将C(x)左移R位，则可表...
CRC 生成多项式
lonffy的专栏
03-31 6331
是接受方和发送方的一个约定，也就是一个二进制数，在整个传输过程中，这个数始终保持不变。 在发送方,利用生成多项式对信息多项式做模2除生成校验码。在接受方利用生成多项式对收到的编码多项式做模2除检测和确定错误位置。 应满足以下条件： a、生成多项式的最高位和最低位必须为1。 b、当被传送信息（CRC码）任何一位发生错误时，被生成多项式做模2除后应该使余数不为0。 c、不同位发生错误时，应该
CRC 算法生成多项式
u012252959的博客
09-19 1万+
标准的CRC算法的生成多项式： 标准 生成多项式 16进制表示 CRC12 x^12 + x^11 + x^3 + x^2 + x + 1 0x80F CRC16 x^16 + x^15 + x^2 + 1 0x...
链表实现多项式的加减及求导运算
11-03
C语言下链表实现多项式的加减及求导运算。
一元多项式计算器.zip_C++_attentionyhs_单链表实现一元多项式_数据结构_表达式 计算器
07-14
请实现求M(x)=Am(x)+Bn(x)、M(x)=Am(x)-Bn(x)、M(x)=Am(x)×Bn(x)以及计算M(x)=0的根，计算多项式在x处的值，求多项式M的导函数M，并将结果保存在文本文件中。 （3）多项式的输出形式为类数学表达式。例如，多项式...
C语言：一元多项式加减法运算（链表 附答案）.docx
10-26
《C语言实现一元多项式加减法运算的链表方法》 在计算机科学中，数据结构和算法是解决问题的基础工具。本篇文章将探讨如何使用C语言通过链表实现一元多项式的加减法运算。这是一道适合初学者的链表实践题目，通过这...
哈工大数据结构实验一_一元多项式计算器
03-26
设计线性表的动态或者静态链式存储结构，并实现一个一元多项式的计算器。 实验要求： 以动态或者静态链表存储一元多项式，在此基础上按要求完成对一元多项式 的运算。（为保证多项式的值的准确性，多项式的系数可以...
链表线性结构多项式加减乘除.doc
09-27
实验结果表明，我们的链表线性结构可以正确地存储和操作多项式，并且可以实现多项式的加减乘除操作和计算多项式值。 五、经历体会 通过本实验，我们了解了链表线性结构的应用于多项式加减乘除操作，并掌握了链表的...
CRC校验的原理
sinat_34875384的博客
10-05 1890
CRC是什么？ CRC全称是：Cyclic Redundancy Check，翻译过来就是：循环冗余校验码。是在数据通信领域中一种十分常用的查错校验码，和串口通信中常用的奇偶校验是属于同一种类型的。都是进行数据查错的算法，而不具有纠错能力。 CRC的所采用的多项式是什么 数据发送方（TX）与接收方（RX）进行交换时，采用CRC进行数据检错时，确定数据在传送过程中没有发生错误。其基本实现原理是TX侧在一个将要传送的数据包后加上N位CRC校验码，RX侧接收 数据包+N位CRC校验码。而添加CRC校验码的基本原则
CRC 常用多项式 与 计算代码
热门推荐
Sunning Pig 的专栏
12-28 3万+
常用多项式： 生成多项式的选取应满足以下条件：     a、生成多项式的最高位和最低位必须为1。     b、当被传送信息（CRC码）任何一位发生错误时，被生成多项式做模2除后，应该使余数不为0。     c、不同位发生错误时，应该使余数不同。     d、对余数继续做模2除，应使余数循环。 主要的生成多项式G(x)有以下几种： 名称 生成多项式 ...
CRC算法详解
学而不思则罔
08-29 3535
原文出处：http://blog.csdn.net/sparkliang/article/details/5671510 感谢作者的详解。转到此处以备学习。 作为blog再次发出来，详细描述一下CRC32算法的推导过程。 CRC算法的数学基础 CRC算法的数学基础就不
CRC校验的计算方法和示例
最新发布
不知道你是通过何种途径访问到这里，总之欢迎来到red velet的博客
10-26 2485
CRC多项式校验计算方法
CRC的计算
qq_45712170的博客
10-20 1万+
用多项式来表示循环冗余检验过程。 多项式P（X） = X4 + X3 + 1表示除数P=11001 现假设选择的CRC生成多项式为P（X） = X4 + X3 + 1，要求出二进制序列10110011的CRC校验码。下面是具体的计算过程： （1）首先把生成多项式转换成二进制数，由G（X） = X4 + X3 + 1可以知道（，它一共是5位（总位数等于最高位的幂次加1，即4+1=5），然后根据多项式...
crc生成多项式怎么算_FPGA-CRC校验学习笔记
weixin_36410316的博客
01-15 3230
以太网帧需要对数据进行CRC校验，原理部分参考以下文章：https://blog.51cto.com/winda/1063951https://www.cnblogs.com/masonzhang/p/10261855.html以太网帧需要进行CRC32校验，FPGA开发一般使用的是CRC32_d4.v这个代码进行校验和的计算，输入数据是4比特，初始值是32’hffffffff，代码是组合逻辑实现...
链表实现多项式的加法(C语言)
qq_67574411的博客
08-02 1546
用链表存储一个多项式，那么该链表的每一个结点就代表多项式的某一项。所以我们的每一个结点必须包含三个信息：多项式的系数、多项式的指数以及指向下一个结点的指针。
crc生成多项式怎么算_CRC算法的硬件电路实现：串行电路和并行电路
weixin_35969301的博客
01-19 1814
IC君的第38篇原创文章上一篇文章讲述了CRC 的数学原理和通项式选择，大家可以点击下面的链接阅读：想知道数据传输的正确性？CRC算法来检查这一篇文章聊一聊CRC算法的硬件电路实现：串行电路和并行电路。下面的内容还是IC君的朋友文武写的，IC君稍微做了优化排版和少量的编辑工作提升大家的阅读体验。1CRC硬件电路的实现很简单，下图给出教科书上任意生成多项式G(X)=gnXn+gn-1Xn...
使用链表实现多项式求值完整代码 数据结构
05-28
下面是使用链表实现多项式求值的完整代码，包含数据结构的定义和相关函数的实现： ```cpp #include #include using namespace std; // 定义多项式项结构体 struct PolyNode { int coef; // 系数 int exp; // ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值