数据结构课程设计心得体会通用4篇

某些事情让我们心里有了一些心得后，不妨将其写成一篇心得体会，让自己铭记于心，通过写心得体会，可以帮助我们总结积累经验。那么心得体会到底应该怎么写呢？下面是小编辛苦为大家带来的数据结构课程设计心得体会通用4篇，希望可以启发、帮助到大家。

数据结构课程设计 篇1

数据结构课程设计

1、 赫夫曼编码器

设计一个利用赫夫曼算法的编码和译码系统，重复地显示并处理以下项目，直到选择退出为止。 要求：

1) 将权值数据存放在数据文件（文件名为data.txt，位于执行程序的当前目录中）

2) 初始化：键盘输入字符集大小26、26个字符和26个权值（统计一篇英文文章中26个字母），建立哈夫曼树；

3) 编码：利用建好的哈夫曼树生成哈夫曼编码；

4) 输出编码（首先实现屏幕输出，然后实现文件输出）； 5) 界面优化设计。

代码如下：

#include#include#include

typedef struct HTNode

//结构体 { int Weight;

char ch; int Parent,Lchild,Rchild; }HTNode; typedef char * * HCode;

void Save(int n,HTNode *HT)

//把权值保存到文件 {

FILE * fp;

int i;

if（（fp=fopen(“data.txt”，“wb”））==NULL)

{

printf（“cannot open filen”）；

return;

}

for(i=0;i

if(fwrite（&HT[i]。Weight,sizeof(struct HTNode），1,fp)！=1)

printf（“file write errorn”）；

fclose(fp)；

system（“cls”）；

printf（“保存成功！”）；

}

void Create_H(int n,int m,HTNode *HT)

//建立赫夫曼树，进行编码 {

int w,k,j; char c; for(k=1;k<=m;k++) {

if(k<=n)

{

printf（“n请输入权值和字符（用空格隔开）: ”）；

scanf（“%d”，&w）；

scanf（“ %c”，&c）； HT[k]。ch=c;

HT[k]。Weight=w;

}

else HT[k]。Weight=0;

HT[k]。Parent=HT[k]。Lchild=HT[k]。Rchild=0; }

int p1,p2,w1,w2;

for(k=n+1;k<=m;k++) {

p1=0;p2=0;

w1=32767;w2=32767;

for(j=1;j<=k-1;j++)

{

if(HT[j]。Parent==0)

{

if(HT[j]。Weight

{

w2=w1;p2=p1;

w1=HT[j]。Weight;

p1=j;

}

else if(HT[j]。Weight

{

w2=HT[j]。Weight;

p2=j;

}

}

} HT[k]。Lchild=p1;HT[k]。Rchild=p2; HT[k]。Weight=HT[p1]。Weight+HT[p2]。Weight;

HT[p1]。Parent=k;HT[p2]。Parent=k;

} printf（“输入成功！”）； }

void Coding_H(int n,HTNode *HT)

//对结点进行译码 { int k,sp,fp,p; char *cd; HCode HC;

HC=（HCode)malloc（(n+1）*sizeof(char *）)；

cd=（char *）malloc（n*sizeof(char)）； cd[n-1]=''；

printf（“************************n”）； printf（“Char Codingn”）；

for(k=1;k<=n;k++)

{

sp=n-1;p=k;fp=HT[k]。Parent;

for（；fp!=0;p=fp,fp=HT[fp]。Parent）

if(HT[fp]。Lchild==p)

cd[--sp]='0'；

else

cd[--sp]='1'；

HC[k]=（char *）malloc（（n-sp）*sizeof(char)）；

strcpy（HC[k]，&cd[sp]）；

printf(“%c

%sn”，HT[k]。ch,HC[k])；

}

printf（“************************n”）； free(cd) ； } void Read(int n,HTNode *HT)

//从文件中读出数据 {

int i; FILE * fp; if（（fp=fopen(“data.txt”，“rb”））==NULL) {

printf（“cannot open filen”）；

exit(0)； } for(i=0;i

fread（&HT[i]。Weight,sizeof(struct HTNode），1,fp)； // printf（“%d n”，HT[i]。Weight）；

} Coding_H(n,HT)；

fclose(fp)； }

void Print_H(int m,HTNode *HT)

//输出赫夫曼造树过程 { int k; printf（“************************n”）； printf(“Num Weight

Par LCh RCh n”)； for(k=1;k<=m;k++) {

printf（“%d ”，k）；

printf(“

%d”，HT[k]。Weight)；

printf(“

%d”，HT[k]。Parent)；

printf(“

%d”，HT[k]。Lchild)；

printf(“

%dn”，HT[k]。Rchild)；

} printf（“************************n”）； }

void Decode(int m,HTNode *HT)

//对输入的电文进行译码 { int i,j=0; char a[10]； char endflag='2'； i=m; printf（“输入发送的编码，以‘2’结束:”）； scanf（“%s”，&a）； printf（“译码后的字符：”）； while（a[j]！='2'） {

if（a[j]=='0'）

i=HT[i]。Lchild;

else i=HT[i]。Rchild;

if(HT[i]。Lchild==0)

//HT[i]是叶结点

{

printf（“%c”，HT[i]。ch）；

i=m;

//回到根结点

}

j++； } printf（“n”）； if（HT[i]。Lchild!=0&&a[j]！='2'）

printf（“ERROR”）； }

int main()

//主函数 { int n,m,c; HTNode HT[N]； do {

system（“color 2f”）；

//运行环境背景颜色。

printf（“nntt*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=ntt”）；

printf（“nttt 赫夫曼编译码系统 ttt”）；

printf（“nntt*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=ntt”）；

printf（“nttt1.输入权值、字母nttt2.把数据写入文件nttt3.输出赫夫曼编码表nttt”）；

printf（“4.输出赫夫曼译码表nttt5.输入编码并译码。nttt6.从文件中读出数据nttt7.退出”）；

printf（“nnttt请选择:”）；

scanf（“%d”，&c）；

switch(c)

{

case 1:system（“cls”）；printf（“输入多少结点:”）；

scanf（“%d”，&n）；m=2*n-1;Create_H(n,m,HT)；break;

case 2:system（“cls”）；Save(n,HT)；break;

case 3:system（“cls”）；Print_H(m,HT)；break;

case 4:system（“cls”）；Coding_H(n,HT)；break;

case 5:system（“cls”）；Decode(m,HT)；break;

case 6:system（“cls”）；Read(n,HT)；break;

case 7:system（“cls”）；exit(0)；

}

}while(1)； return 0; }

运行界面如下：

2、 学生成绩管理（链表实现） 要求：

实现如下功能：增加、查找、删除、输出、退出。

代码如下：

#include#include#includetypedef struct score

//定义成绩信息结构体 {

char Number[20]； char Name[20]； char Chinese[20]； char English[20]； char Math[20]； }score; typedef struct node_score

//定义成绩信息链表结点，包括数据域和指针域 {

score data; struct node_score *next; }node_score,*p_node_score; p_node_score headScore;//定义链表的头指针为全局变量 void PrintScore(score s) //输出信息函数 { printf（“ %10s”，s.Number）； printf(“ |

%-6s”，s.Name)； printf(“

|

%-3s”，s.Chinese)； printf(“

|

%-3s”，s.English)；

printf(“ |

%-3sn”，s.Math)； } void View()//输出函数 {

p_node_score pNodeScore;

pNodeScore=headScore; printf(“

学号

|

姓名

| 语文成绩

| 英语成绩| 高数成绩n”)； while(pNodeScore ！= NULL) {

PrintScore(pNodeScore->data)；//输出学生信息和成绩信息

pNodeScore=pNodeScore->next; } } void Add() {

p_node_score pNodeScore; // 定义一个节点

pNodeScore=（p_node_score)malloc(sizeof(node_score)）；//为节点分配存储空间

printf（“请输入学号：”）； scanf(“%s”，pNodeScore->data.Number)； printf（“请输入姓名：”）； scanf(“%s”，pNodeScore->data.Name)； printf（“请输入语文成绩：”）； scanf(“%s”，pNodeScore->data.Chinese)； printf（“请输入英语成绩：”）； scanf(“%s”，pNodeScore->data.English)； printf（“请输入高数成绩：”）； scanf(“%s”，pNodeScore->data.Math)； if(headScore==NULL) { //如果头结点为空

headScore=pNodeScore;

pNodeScore->next=NULL; } else

{ //如果头结点不为空

pNodeScore->next=headScore;

headScore=pNodeScore;//将头结点新结点

} } void Input（) { int n,i; printf(“输入几个学生的数据：”）； scanf（“%d”，&n）； for(i=0;i

Add（)； printf（“输入成功！”）； } int Delete(） { p_node_score pNodeScore,p1; //p1为pNodeScore的前驱

p1=headScore; if(p1==NULL) {

printf（“成绩表中没有数据！请先添加数据！n”）；

return 0; } char DeleteNumber[20]；

printf（“请数入要删除的学生学号:”）； scanf（“%s”，DeleteNumber）； if(strcmp(p1->data.Number,DeleteNumber)==0)

{ //如果要删除的结点在第一个

headScore=p1->next;

pNodeScore=p1;

printf（“学号为%s的学生信息已经删除！n”，DeleteNumber）；

return 0; } else

{

pNodeScore=p1->next;

while(pNodeScore!=NULL)

{

if(strcmp(pNodeScore->data.Number,DeleteNumber)==0)

{

p1->next=pNodeScore->next;

printf（“学号为%s的学生信息已经删除！n”，DeleteNumber）；

return 0;

}

else

{ //否则，结点向下一个，p1仍为pNodeScore的前驱

p1=pNodeScore;

pNodeScore=pNodeScore->next;

}

} } printf（“没有此学号的学生！”）； } int Change() {

p_node_score pNodeScore;

pNodeScore=headScore; if(pNodeScore==NULL) {

printf（“成绩表中没有数据！请先添加数据！n”）；

return 0; } char EditNumber[20]； printf（“请输入你要修改的学生学号：”）； scanf（“%s”，EditNumber）； while(pNodeScore!=NULL) {

if(strcmp(pNodeScore->data.Number,EditNumber)==0)

{ //用strcmp比较两字符串是否相等，相等则返回0

printf（“原来的学生成绩信息如下：n”）； //输出原来的成绩信息

printf(“

学号

|

姓名

| 语文成绩

| 英语成绩| 高数成绩n”)；

PrintScore(pNodeScore->data)；

printf（“语文新成绩:”）；

scanf(“%s”，pNodeScore->data.Chinese)；

printf（“英语新成绩:”）；

scanf(“%s”，pNodeScore->；

printf（“高数新成绩:”）；

scanf(“%s”，pNodeScore->data.Math)；

printf（“成绩已经修改！”）；

return 0;

}

pNodeScore=pNodeScore->next; //如果不相等，pNodeScore则指向下一个结点

} printf（“没有此学号的学生！n”）； //如果找到最后都没有，则输出没有此学号的学生

} int Find() {

p_node_score pNodeScore;

pNodeScore=headScore; if(pNodeScore==NULL) {

printf（“成绩表中没有数据！请先添加数据！n”）；

return 0; } char FindNumber[20]； printf（“请输入你要查找的学生学号：”）； scanf（“%s”，FindNumber）； while(pNodeScore!=NULL) {

if(strcmp(pNodeScore->data.Number,FindNumber)==0)

{

printf（“你要查找的学生成绩信息如下：n”）；

printf(“

学号

|

姓名

| 语文成绩

| 英语成绩| 高数成绩n”)；

PrintScore(pNodeScore->data)；

return 0;

}

pNodeScore=pNodeScore->next; } printf（“没有此学号的学生！n”）； } int main()

//主函数 { int choice=0; headScore=NULL; int c; do {

system（“color 2f”）；

//运行环境背景颜色。

printf（“nntt*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=ntt”）；

printf（“nttt 学生成绩管理系统 ttt”）；

printf（“nntt*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=ntt”）；

printf（“nttt1.输入成绩信息nttt2.输出成绩信息nttt3.添加成绩信息nttt”）；

printf（“4.修改成绩信息nttt5.删除成绩信息nttt6.查询成绩信息nttt7.退出”）；

printf（“nnttt请选择:”）；

scanf（“%d”，&c）；

switch(c)

{

case 1:system（“cls”）；Input()；break;

case 2:system（“cls”）；View()；break;

case 3:system（“cls”）；Add()；break;

case 4:system（“cls”）；Change()；break;

case 5:system（“cls”）；Delete()；break;

case 6:system（“cls”）；Find()；break;

case 7:system（“cls”）；exit(0)；

}

}while(1)； return 0; }

运行界面如下：

数据结构课程设计 篇2

一，课程题目

（算符优先法计算算数表达式）以字符序列的形式从终端输入语法正确的、不含变量的整数表达式。利用教材表3.1（P53）给出的算符优先关系，实现对于算术四则混合运算（加、减、乘、除）表达式的求值。例如：7+（4-2）*3+12/2=19。注：按照四舍五入的方式将四则运算结果取整。

二，程序设计思想

在程序中分别设立一个运算符栈（OPTR 栈），用于存储‘+’，‘-’，‘*’，‘/’，‘#’（�’用于判断算术表达式结束），和一个操作数栈（OPND栈），用于存放整数，输入算式后，先将数字与运算符分开入i栈，若为数字则先用转换函数将char类型的数转换为int型并进入操作数栈，若为运算符则根据教材表3.1（P53）给出的算符优先级关系，判断栈顶运算符和从键盘取得的运算符作优先级比较，若取得的运算符优先级高则进栈，直到取得运算符优先级低的，则将操作数取出作operate运算后存入栈顶，反复操作知道遇到�’，则结束运算，输出栈顶元素即为结果。 三，程序流程图

四，程序关键代码设计

本次程序设计共调用了12个方法分别是：

InitNumStack，ParseInt，PushNum，PopNum ，InitCalStack，PopCal ，PushCal，In，GetTopCal，GetTopNum，Preced，Operate。 其中

ParseInt方法

int ParseInt（char c[]）{ int number[5]，i; for(i=0;i<5;i++){

number[i]=（int)(c[i]）-48; } i=10000*number[0]+1000*number[1]+100*number[2]+10 *number[3]+number[4]； return i; } 为将输入的数字字符型转换为整型的转换函数，通过Ascall表的转换关系，将输入的字符型数字转换为整型。在入栈前进行此方法，以便整型数的计算。 Preced，Operate函数

char Preced(char a ， char b){ char c[7]={'+'，'-'，'*'，'/'，'（'，'）'，'#'}； char d[7][7]={ {'>'，'>'，'<'，'<'，''，'>'}， {'>'，'>'，'<'，'<'，''，'>'}， {'>'，'>'，'>'，'>'，''，'>'}， {'>'，'>'，'>'，'>'，''，'>'}， {'<'，'<'，'<'，'<'，''，'>'，'>'，'>'，' '，'>'，'>'}， {'<'，'<'，'<'，'<'，'<'，' '，'='}， }； int Operate （int a,char theta,int b){ int c ； if (theta=='+'）{

c=a+b; return c; } if （theta=='-'）{

c=a-b; return c; } if （theta=='*'）{

c=a*b; return c; } if （theta=='/'）{

c=a/b; return c; } return 0; } 其中preced是判定运算符栈的栈顶运算符C1与读入的运算符C2之间优先关系函数；Opearte为进行二元运算aCb的函数，如果是编译表达式，则产生这个运算的一组相应的指令并返回存放结果的中间变量名；如果是解释执行表达式，则直接进行该运算，并返回运算结果。 五，程序源代码以及运行结果

#includetypedef struct{ int *base; int *top; int Stacksize; }SqlNum; void InitNumStack（SqlNum &S){ S.base=(int *）malloc（100*sizeof(int)）； S.top=S.base; S.Stacksize=100; } int ParseInt（char c[]）{ int number[5]，i; for(i=0;i<5;i++){

number[i]=（int)(c[i]）-48; } i=10000*number[0]+1000*number[1]+100*number[2]+10*number[3]+number[4]； return i; } void PushNum（SqlNum &S,int c){ *S.top=c; S.top++； } int PopNum(SqlNum &S){ int c; S.top--; c=*S.top; return c; } typedef struct{ char *base; char *top; int Stacksize; }SqlCal; void InitCalStack(SqlCal &S){ S.base=(char *）malloc（100*sizeof(char)）； S.top=S.base; S.Stacksize=100; } void PushCal(SqlCal &S,char c){ *S.top=c; S.top++； } char PopCal(SqlCal &S){ char c; S.top--; c=*S.top; return c; }

int In（char c,char s[]）{ int i; for(i=0;i

if（c==s[i]）

return 1;

return 0; }

char GetTopCal(SqlCal &s){ char c; c=*(s.top-1)； return c; } int GetTopNum(SqlNum &s){ int c; c=*(s.top-1)； return c; } char Preced(char a ， char b){ char c[7]={'+'，'-'，'*'，'/'，'（'，'）'，'#'}； char d[7][7]={ {'>'，'>'，'<'，'<'，''，'>'}， {'>'，'>'，'<'，'<'，''，'>'}， {'>'，'>'，'>'，'>'，''，'>'}， {'>'，'>'，'>'，'>'，''，'>'}， {'<'，'<'，'<'，'<'，''，'>'，'>'，'>'，' '，'>'，'>'}， {'<'，'<'，'<'，'<'，'<'，' '，'='}， }； if（a=='+'）{

if（b=='+'）{

return d[0][0]；}

if（b=='-'）{

return d[0][1]；}

if（b=='*'）{

return d[0][2]；}

if（b=='/'）{

return d[0][3]；}

if（b=='('）{

return d[0][4]；}

if（b=='）'){

return d[0][5]；}

if（b=='#'）{

return d[0][6]；} } if（a=='-'）{

if（b=='+'）{

return d[1][0]；}

if（b=='-'）{

return d[1][1]；}

if（b=='*'）{

return d[1][2]；}

if（b=='/'）{

return d[1][3]；}

if（b=='('）{

return d[1][4]；}

if（b=='）'){

return d[1][5]；}

if（b=='#'）{

return d[1][6]；} } if（a=='*'）{

if（b=='+'）{

return d[2][0]；}

if（b=='-'）{

return d[2][1]；}

if（b=='*'）{

return d[2][2]；}

if（b=='/'）{

return d[2][3]；}

if（b=='('）{

return d[2][4]；}

if（b=='）'){

return d[2][5]；}

if（b=='#'）{

return d[2][6]；} } if（a=='/'）{

if（b=='+'）{

return d[3][0]；}

if（b=='-'）{

return d[3][1]；}

if（b=='*'）{

return d[3][2]；}

if（b=='/'）{

return d[3][3]；}

if（b=='('）{

return d[3][4]；}

if（b=='）'){

return d[3][5]；}

if（b=='#'）{

return d[3][6]；} } if（a=='('）{

if（b=='+'）{

return d[4][0]；}

if（b=='-'）{

return d[4][1]；}

if（b=='*'）{

return d[4][2]；}

if（b=='/'）{

return d[4][3]；}

if（b=='('）{

return d[4][4]；}

if（b=='）'){

return d[4][5]；}

if（b=='#'）{

return d[4][6]；} } if（a=='）'){

if（b=='+'）{

return d[5][0]；}

if（b=='-'）{

return d[5][1]；}

if（b=='*'）{

return d[5][2]；}

if（b=='/'）{

return d[5][3]；}

if（b=='('）{

return d[5][4]；}

if（b=='）'){

return d[5][5]；}

if（b=='#'）{

return d[5][6]；} } if（a=='#'）{

if（b=='+'）{

return d[6][0]；}

if（b=='-'）{

return d[6][1]；}

if（b=='*'）{

return d[6][2]；}

if（b=='/'）{

return d[6][3]；}

if（b=='('）{

return d[6][4]；}

if（b=='）'){

return d[6][5]；}

if（b=='#'）{

return d[6][6]；} } return 0; } int Operate （int a,char theta,int b){ int c ； if (theta=='+'）{

c=a+b; return c; } if （theta=='-'）{

c=a-b; return c; } if （theta=='*'）{

c=a*b; return c; } if （theta=='/'）{

c=a/b; return c; } return 0; } void main（){ SqlCal OPTR; SqlNum OPND; char c,d[5]={'0'，'0'，'0'，'0'，'0'}； int f=0; char op[]={'+'，'-'，'*'，'/'，'（'，'）'，'#'}； InitCalStack(OPTR)； InitNumStack(OPND)； printf（“请输入算式并在尾部添加一�号n”）； c=getchar（）； PushCal（OPTR,'#'）； while(c!='#'||GetTopCal(OPTR)！='#'） { if （！In（c,op））

{

d[0]=d[1]；

d[1]=d[2]；

d[2]=d[3]；

d[3]=d[4]；

d[4]=c;

c=getchar()； f=1;

}

else

{

if(f==1){

PushNum（OPND,ParseInt(d)）；

d[0]='0'；d[1]='0'；d[2]='0'；d[3]='0'；d[4]='0'；

f=0;

}

switch（Preced(GetTopCal(OPTR)，c)）

{

case'<':

PushCal(OPTR,c)；

c=getchar()；

break;

case'=':

PopCal(OPTR)；

c=getchar()；

break;

case'>':

char theta;int a;int b;

theta=PopCal(OPTR)；

b=PopNum(OPND)；

a=PopNum(OPND)；

PushNum（OPND,Operate(a,theta,b)）；

break;

}

} } printf（“%dn”，GetTopNum（OPND））； }

程序运行结果: 六，心得体会

通过这次编程，我发现很多编程过程中的不足与问题，很多问题由于考虑不全面，导致程序运行失败。还有一些小问题，比如字母的大小写，括号的遗漏，语法书写错误等等一些基础错误，也是让我体会很深写程序要谨慎仔细。

数据结构课程设计心得体会 篇3

本次课程设计，使我对《数据结构》这门课程有了更深入的理解。我的课程设计题目是线索二叉树的运算。刚开始做这个程序的时候，感到完全无从下手，甚至让我觉得完成这次程序设计根本就是不可能的，于是开始查阅各种资料以及参考文献，之后便开始着手写程序，写完运行时有很多问题。特别是实现线索二叉树的删除运算时很多情况没有考虑周全，经常运行出现错误，但通过同学间的帮助最终基本解决问题。

在本课程设计中，我明白了理论与实际应用相结合的重要性，并提高了自己组织数据及编写大型程序的能力。培养了基本的、良好的程序设计技能以及合作能力。这次课程设计同样提高了我的综合运用所学知识的能力。并对VC有了更深入的了解。《数据结构》是一门实践性很强的课程，上机实习是对学生全面综合素质进行训练的一种最基本的方法，是与课堂听讲、自学和练习相辅相成的、必不可少的一个教学环节。上机实习一方面能使书本上的知识变“活”，起到深化理解和灵活掌握教学内容的目的；另一方面，上机实习是对学生软件设计的综合能力的训练，包括问题分析，总体结构设计，程序设计基本技能和技巧的训练。此外，还有更重要的一点是：机器是比任何教师更严厉的检查者。因此，在“数据结构”的学习过程中，必须严格按照老师的要求，主动地、积极地、认真地做好每一个实验，以不断提高自己的编程能力与专业素质。

通过这段时间的课程设计，我认识到数据结构是一门比较难的课程。需要多花时间上机练习。这次的程序训练培养了我实际分析问题、编程和动手能力，使我掌握了程序设计的基本技能，提高了我适应实际，实践编程的能力。

总的来说，这次课程设计让我获益匪浅，对数据结构也有了进一步的理解和认识。

2012数据结构课程设计 篇4

数 据 结 构

课程设计报告

题 目： 一元多项式计算 专 业： 信息管理与信息系统 班 级： 2012级普本班 学 号： 201201011367 姓 名： 左帅帅 指导老师： 郝慎学 时 间：

一、课程设计题目分析

本课程设计要求利用C语言或C++编写，本程序实现了一元多项式的加法、减法、乘法、除法运算等功能。

二、设计思路

本程序采用C语言来完成课程设计。

1、首先，利用顺序存储结构来构造两个存储多项式A(x)和 B(x)的结构。

2、然后把输入，加，减，乘，除运算分成五个主要的模块：实现多项式输入模块、实现加法的模块、实现减法的模块、实现乘法的模块、实现除法的模块。

3、然后各个模块里面还要分成若干种情况来考虑并通过函数的嵌套调用来实现其功能，尽量减少程序运行时错误的出现。

4、最后编写main()主函数以实现对多项式输入输出以及加、减、乘、除，调试程序并将不足的地方加以修改。

三、设计算法分析

1、相关函数说明：

（1）定义数据结构类型为线性表的链式存储结构类型变量

typedef struct Polynomial{}

（2）其他功能函数

插入函数void Insert(Polyn p,Polyn h)

比较函数int compare(Polyn a,Polyn b)

建立一元多项式函数Polyn Create(Polyn head,int m)

求解并建立多项式a+b，Polyn Add(Polyn pa,Polyn pb)

求解并建立多项式a-b，Polyn Subtract(Polyn pa,Polyn pb) 2

求解并建立多项式a*b，Polyn Multiply(Polyn pa,Polyn pb)

求解并建立多项式a/b，void Device(Polyn pa,Polyn pb)

输出函数输出多项式，void Print(Polyn P)

销毁多项式函数释放内存，void Destroy(Polyn p)

主函数，void main（）

2、主程序的流程基函数调用说明 (1)typedef struct Polynomial {

float coef;

int expn;

struct Polynomial *next; } *Polyn,Polynomial;

在这个结构体变量中coef表示每一项前的系数，expn表示每一项的指数，polyn为结点指针类型，属于抽象数据类型通常由用户自行定义，Polynomial表示的是结构体中的数据对象名。

（2）当用户输入两个一元多项式的系数和指数后，建立链表，存储这两个多项式，主要说明如下：

Polyn CreatePolyn(Polyn head,int m)建立一个头指针为head、项数为m的一元多项式

p=head=（Polyn)malloc(sizeof(struct Polynomial)）；为输入的多项式申请足够的存储空间

p=（Polyn)malloc(sizeof(struct Polynomial)）；建立新结点以接收数据

Insert(p,head)； 调用Insert函数插入结点

这就建立一元多项式的关键步骤

（3）由于多项式的系数和指数都是随即输入的，所以根据要求需要对多项式按指数进行降幂排序。在这个程序模块中，使用链表，根据对指数大小的比较，对各种情况进行处理，此处由于反复使用指针对各个结点进行定位，找到合适的位置再利用void Insert(Polyn p,Polyn h)进行插入操作。 (4)加、减、乘、除、的算法实现：

在该程序中，最关键的一步是实现四则运算和输出，由于加减算法原则是一样，减法可通过系数为负的加法实现；对于乘除算法的大致流程都是：首先建立多项式a*b，a/b，然后使用链表存储所求出的乘积，商和余数。这就实现了多项式计算模块的主要功能。

（5）另一个子函数是输出函数 PrintPolyn（）；

输出最终的结果，算法是将最后计算合并的链表逐个结点依次输出，便得到整链表，也就是最后的计算式计算结果。由于考虑各个结点的指数情况不同，分别进行了判断处理。

四、程序新点

通过多次写程序，发现在程序在控制台运行时总是黑色的，本次写程序就想着改变一下，于是经过查资料利用system（“Color E0”）；可以函数解决，这里“E0，”E是控制台背景颜色，0是控制台输出字体颜色。

五、设计中遇到的问题及解决办法

首先是，由于此次课程设计里使用指针使用比较多，自己在指针多的时候易脑子混乱出错，对于此问题我是采取比较笨的办法在稿纸上写明白后开始进行 4

代码编写。

其次是，在写除法模块时比较复杂，自己通过查资料最后成功写出除法模块功能。

最后是，前期分析不足开始急于写代码，中途出现各种问题，算是给自己以后设计时的一个经验吧。

六、测试（程序截图）

1、数据输入及主菜单

2、加法和减法模块

3、乘法和除法模块

七、总结

通过本次应用C语言设计一元多项式基本计算程序，使我更加巩固了C语言程序设计的知识，以前对指针这一点使用是比较模糊，现在通过此次课程设计对指针理解的比较深刻了。而且对于数据结构的相关算法和函数的调用方面知识的加深。本次的课程设计，一方面提高了自己独立思考处理问题的能力；另一方面使自己再设计开发程序方面有了一定的小经验和想法，对自己以后学习其他语言程序设计奠定了一定的基础。

八、指导老师评语及成绩

附录：（课程设计代码）

#includetypedef struct Polynomial {

float coef; 6

int expn;

struct Polynomial *next; } *Polyn,Polynomial;

//Polyn为结点指针类型 void Insert(Polyn p,Polyn h) {

if(p->coef==0) free(p)；

//系数为0的话释放结点

else

{

Polyn q1,q2;

q1=h;q2=h->next;

while(q2&&p->expnexpn)//查找插入位置

{

q1=q2; q2=q2->next; }

if(q2&&p->expn==q2->expn)//将指数相同相合并 {

q2->coef+=p->coef;

free(p)；

if(！q2->coef)//系数为0的话释放结点

{ q1->next=q2->next; free(q2)； }

}

else { p->next=q2; q1->next=p;

}//指数为新时将结点插入

} 7

} //建立一个头指针为head、项数为m的一元多项式 Polyn Create(Polyn head,int m) {

int i;

Polyn p;

p=head=（Polyn)malloc(sizeof(struct Polynomial)）；

head->next=NULL;

for(i=0;i

{

p=（Polyn)malloc(sizeof(struct Polynomial)）；//建立新结点以接收数据

printf（“请输入第%d项的系数与指数:”，i+1）；

scanf(“%f %d”，&p->coef,&p->expn)；

Insert(p,head)；

//调用Insert函数插入结点

}

return head; } //销毁多项式p void Destroy(Polyn p) {

Polyn q1,q2;

q1=p->next; 8

q2=q1->next;

while(q1->next)

{

free(q1)；

q1=q2;//指针后移

q2=q2->next;

} } //输出多项式p int Print(Polyn P) {

Polyn q=P->next;

int flag=1;//项数计数器

if（！q） //若多项式为空，输出0

{

putchar（'0'）；

printf（“n”）；

return;

}

while(q)

{

if(q->coef>0&&flag!=1) putchar（'+'）； //系数大于0且不是第一项 9

if(q->coef!=1&&q->coef!=-1)//系数非1或-1的普通情况

{

printf(“%g”，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++；

}

printf（“n”）； } int compare(Polyn a,Polyn b) {

if(a&&b)

{

if(！b||a->expn>b->expn) return 1;

else if(！a||a->expnexpn) return -1;

else return 0;

}

else if（！a&&b） return -1;//a多项式已空，但b多项式非空

else return 1;//b多项式已空，但a多项式非空 } //求解并建立多项式a+b，返回其头指针 Polyn Add(Polyn pa,Polyn pb) {

Polyn qa=pa->next;

Polyn qb=pb->next;

Polyn headc,hc,qc;

hc=（Polyn)malloc(sizeof(struct Polynomial)）；//建立头结点 11

hc->next=NULL;

headc=hc;

while(qa||qb){

qc=（Polyn)malloc(sizeof(struct Polynomial)）；

switch（compare(qa,qb)）

{

case 1:

qc->coef=qa->coef;

qc->expn=qa->expn;

qa=qa->next;

break;

case 0:

qc->coef=qa->coef+qb->coef;

qc->expn=qa->expn;

qa=qa->next;

qb=qb->next;

break;

case -1:

qc->coef=qb->coef;

qc->expn=qb->expn;

qb=qb->next;

break; 12

}

if(qc->coef!=0)

{

qc->next=hc->next;

hc->next=qc;

hc=qc;

}

else free(qc)；//当相加系数为0时，释放该结点

}

return headc; } //求解并建立多项式a-b，返回其头指针 Polyn Subtract(Polyn pa,Polyn pb) {

Polyn h=pb;

Polyn p=pb->next;

Polyn pd;

while(p)//将pb的系数取反

{ p->coef*=-1; p=p->next; }

pd=Add(pa,h)；

for(p=h->next;p;p=p->next)

//恢复pb的系数

p->coef*=-1; 13

return pd; } //求解并建立多项式a*b，返回其头指针 Polyn Multiply(Polyn pa,Polyn pb) {

Polyn hf,pf;

Polyn qa=pa->next;

Polyn qb=pb->next;

hf=（Polyn)malloc(sizeof(struct Polynomial)）；//建立头结点

hf->next=NULL;

for(；qa;qa=qa->next)

{

for(qb=pb->next;qb;qb=qb->next)

{

pf=（Polyn)malloc(sizeof(struct Polynomial)）；

pf->coef=qa->coef*qb->coef;

pf->expn=qa->expn+qb->expn;

Insert(pf,hf)；//调用Insert函数以合并指数相同的项

}

}

return hf; }

//求解并建立多项式a/b，返回其头指针 void Device(Polyn pa,Polyn pb) {

Polyn hf,pf,temp1,temp2;

Polyn qa=pa->next;

Polyn qb=pb->next;

hf=（Polyn)malloc(sizeof(struct Polynomial)）；//建立头结点，存储商

hf->next=NULL;

pf=（Polyn)malloc(sizeof(struct Polynomial)）；//建立头结点，存储余数

pf->next=NULL;

temp1=（Polyn)malloc(sizeof(struct Polynomial)）；

temp1->next=NULL;

temp2=（Polyn)malloc(sizeof(struct Polynomial)）；

temp2->next=NULL;

temp1=Add(temp1,pa)；

while(qa!=NULL&&qa->expn>=qb->expn)

{

temp2->next=（Polyn)malloc(sizeof(struct Polynomial)）；

temp2->next->coef=(qa->coef)/(qb->coef)；

temp2->next->expn=(qa->expn)-(qb->expn)；

Insert(temp2->next,hf)；

pa=Subtract（pa,Multiply(pb,temp2)）； 15

qa=pa->next;

temp2->next=NULL;

}

pf=Subtract（temp1,Multiply(hf,pb)）；

pb=temp1;

printf（“商是:”）；

Print(hf)；

printf（“余数是:”）；

Print（pf)； } void main（） { int choose=1; int m,n,flag=0; system（“Color E0”）； Polyn pa=0,pb=0,pc,pd,pf;//定义各式的头指针，pa与pb在使用前付初值NULL printf（“请输入A(x）的项数:”）； scanf（“%d”，&m）； printf（“n”）； pa=Create（pa,m)；//建立多项式A printf（“n”）； printf（“请输入B(x）的项数:”）； 16

scanf（“%d”，&n）； printf（“n”）； pb=Create(pb,n)；//建立多项式B printf（“n”）； printf（“**********************************************n”）； printf(“*

多项式操作菜单

printf（”**********************************************n“）； printf（”tt 1.输出操作n“）； printf（”tt 2.加法操作n“）； printf（”tt 3.减法操作n“）； printf（”tt 4.乘法操作n“）； printf（”tt 5.除法操作n“）； printf（”tt 6.退出操作n“）； printf（”**********************************************n“）； while(choose) {

printf（”执行操作:“）；

scanf（”%d“，&flag）；

switch(flag)

{

case 1:

printf（”多项式A（x）:“）；Print（pa)； *n”）；

printf（“多项式B（x）:”）；Print(pb)；

break;

case 2:

pc=Add(pa,pb)；

printf（“多项式A（x）+B(x):”）； Print(pc)；

Destroy(pc)； break;

case 3:

pd=Subtract(pa,pb)；

printf（“多项式A（x）-B(x):”）； Print(pd)；

Destroy(pd)； break;

case 4:

pf=Multiply(pa,pb)；

printf（“多项式A（x）*B(x):”）；

Print(pf)；

Destroy(pf)；

break;

case 5:

Device(pa,pb)； 18

break;

case 6:

exit(0)；

break;

} }

Destroy(pa)；

Destroy(pb)； }