数据结构课程设计心得体会【优秀8篇】

当我们经过反思，对生活有了新的看法时，通常就可以写一篇心得体会将其记下来，这样就可以总结出具体的经验和想法。应该怎么写才合适呢？读书破万卷下笔如有神，下面虎知道为您精心整理了8篇《数据结构课程设计心得体会》，在大家参考的同时，也可以分享一下虎知道给您的好友哦。

数据结构课程设计 篇一

《数据结构》

课程设计报告

学 号 姓 名 班 级 指导教师

XXX XXX XXX XXX 安徽工业大学计算机学院

2014年6月

利用栈实现迷宫问题的求解

一、问题描述

以一个M*N的长方阵表示迷宫，0和1分别表示迷宫中的通路和墙壁。设计一个程序，对任意设定的迷宫，求出一条从入口到出口的通路，或得出米有通路的结论。

二、设计思路

（1）以二维数组maze[m][n]表示迷宫，数组中元素值为0表示通路，1表示障碍。

（2）其中迷宫的入口位置和出口位置默认于maze数组的起始元素位置和最后个元素位置。

（3）以链表作存储结构的栈类型，实现求解迷宫的非递归程序。

三、数据结构定义 typedef struct{

int x; int y; }item; typedef struct{ int x,y,d; }DataType; typedef struct{ DataType data[1000]； int top; }SeqStack,*PSeqStack;

typedef struct{ DataType data[1000]； int top; }SeqStack,*PSeqStack;

四、程序清单 #include#include#include#define m 6 #define n 8 int maze[m+2][n+2]={{1,1,1,1,1,1,1,1,1,1}，

typedef struct{

{1,0,1,1,1,0,1,1,1,1}， {1,0,0,0,0,1,1,1,1,1}， {1,0,1,0,0,0,0,0,1,1}， {1,0,1,1,1,0,0,1,1,1}， {1,1,0,0,1,1,0,0,0,1}， {1,0,1,1,0,0,1,1,0,1}， {1,1,1,1,1,1,1,1,1,1}}； int x; int y; }item;

item move[4]={{0,1}，{1,0}，{0,-1}，{-1,0}}；

typedef struct{ int x,y,d; }DataType;

typedef struct{ DataType data[1000]； int top; }SeqStack,*PSeqStack;

PSeqStack Init_SeqStack() {

} PSeqStack p; p=（PSeqStack)malloc(sizeof(SeqStack)）； if(p) p->top=-1; return p;

int Empty_SeqStack(PSeqStack p) {

}

int Push_SeqStack(PSeqStack p,DataType x) {

}

int Pop_SeqStack(PSeqStack p,DataType *x) { if(p->top==999) return 0; if(p->top==-1) return 1; else return 0; else {

} p->top++； p->data[p->top]=x; return 1;

} if（Empty_SeqStack(p)） return 0; else {

} *x=p->data[p->top]； p->top--; return 1; void Destroy_SeqStack(PSeqStack *p) {

}

int mazepath(int maze[][n+2]，item move[]，int x0,int y0) {

PSeqStack S; DataType temp; int x,y,d,i,j; if（*p） free（*p）； *p=NULL; return;

temp.x=x0; temp.y=y0; temp.d=-1; S=Init_SeqStack（)； if(！S） {

} Push_SeqStack（S,temp)； while（！Empty_SeqStack(S）） {

Pop_SeqStack(S,&temp)； x=temp.x; y=temp.y; d=temp.d+1; while(d<4) {

i=x+move[d]。x; j=y+move[d]。y; if（0==maze[i][j]） { temp.x=x; printf（“栈初始化失败！！！”）； return 0;

}

}

} temp.y=y; temp.d=d; Push_SeqStack(S,temp)； x=i; y=j; maze[x][y]=-1; if(x==m&&y==n) {

} else d=0; while（！Empty_SeqStack（S）） {

} Destroy_SeqStack（&S）； return 1; Pop_SeqStack(S,&temp)； printf（“(%d,%d）<-”，temp.x,temp.y)； else d++；

} Destroy_SeqStack（&S）； return 0; int main() {

}

五、运行及调试分析 mazepath(maze,move,1,1)； return 0;

六、课程设计总结等

在做实验前，一定要将课本上的知识吃透，因为这是做实验的基础，否则，在做设计程序实验时，这将使你做的难度加大，浪费宝贵的时间。使你事倍功半。做实验时，一定要亲力亲为，务必要将每个步骤，每个细节弄清楚，弄明白，实验后，还要复习，思考，这样，你的印象才深刻，记得才牢固，否则，过后不久你就会忘得一干二净，这还不如不做。通过这次程序设计的实验，使我们学到了不少实用的知识，更重要的是，做实验的过程，思考问题的方法，这与做其他的实验是通用的，真正使我们们受益匪浅。

大数相乘

一、问题描述

本问题中，要求输入两个相对较大的正整数，能够通过程序计算出其结果

二、设计思路

1、输入阶段采用一维数组a[]，b[] 在输入阶段当大数输入时，大数a,b从高位到低位分别依次存入数组a[ ]，b[ ]。

2、调用函数计算阶段采用一维数组c[ ] 在计算过程中，由个位到高位依次计算各位的结果，并依次存入数组c[ ]中。

三、数据结构定义

int x[N]，y[N]，z[N*N]；

四、程序清单 #include#include#define N 80 void mul(int *x,int *y,int *z) { int i,j; for(i=0;i<2*N;i++) z[i]=0; for(i=0;i

五、运行及调试分析

六、课程设计总结。

回顾起此次课程设计，至今我仍感慨颇多，的确，从从拿到题目到完成整个编程，从理论到实践，可以学到很多很多的的东西，同时不仅可以巩固了以前所学过的知识，而且学到了很多在书本上所没有学到过的知识。通过这次课程设计使我懂得了理论与实际相结合是很重要的，只有理论知识是远远不够的，只有把所学的理论知识与实践相结合起来，从理论中得出结论，才能真正提高自己的实际动手能力和独立思考的能力。

数据结构课程设计 篇二

一，课程题目

（算符优先法计算算数表达式）以字符序列的形式从终端输入语法正确的、不含变量的整数表达式。利用教材表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的函数，如果是编译表达式，则产生这个运算的一组相应的指令并返回存放结果的中间变量名；如果是解释执行表达式，则直接进行该运算，并返回运算结果。 五，程序源代码以及运行结果

#include#include #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））； }

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

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

2012数据结构课程设计 篇三

数 据 结 构

课程设计报告

题 目： 一元多项式计算 专 业： 信息管理与信息系统 班 级： 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语言程序设计的知识，以前对指针这一点使用是比较模糊，现在通过此次课程设计对指针理解的比较深刻了。而且对于数据结构的相关算法和函数的调用方面知识的加深。本次的课程设计，一方面提高了自己独立思考处理问题的能力；另一方面使自己再设计开发程序方面有了一定的小经验和想法，对自己以后学习其他语言程序设计奠定了一定的基础。

八、指导老师评语及成绩

附录：（课程设计代码）

#include#include #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)； }

数据结构课程设计 篇四

数据结构课程设计

1、 赫夫曼编码器

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

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

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

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

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

代码如下：

#include#include#include#include #define N 200

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; }

运行界面如下：

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

通过本次课程设计，对图的概念有了一个新的认识，在学习离散数学的时候，总觉得图是很抽象的东西，但是在学习了《数据结构与算法》这门课程之后，我慢慢地体会到了其中的奥妙，图能够在计算机中存在，首先要捕捉他有哪些具体化、数字化的信息，比如说权值、顶点个数等，这也就说明了想要把生活中的信息转化到计算机中必须用数字来完整的构成一个信息库，而图的存在，又涉及到了顶点之间的联系。图分为有向图和无向图，而无向图又是有向图在权值双向相等下的一种特例，如何能在计算机中表示一个双向权值不同的图，这就是一件很巧妙的事情，经过了思考和老师同学的帮助，我用edges[i][j]=up和edges[j][i]=up就能实现了一个双向图信息的存储。对整个程序而言，Dijkstra算法始终都是核心内容，其实这个算法在实际思考中并不难，也许我们谁都知道找一个路径最短的方法，及从顶点一步一步找最近的路线并与其直接距离相比较，但是，在计算机中实现这么一个很简单的想法就需要涉及到很多专业知识，为了完成设计，在前期工作中，基本都是以学习C语言为主，所以浪费了很多时间，比如说在程序中，删除顶点和增加顶点的模块中都有和建图模块相互重复的函数，但是由于技术的原因，只能做一些很累赘的函数，可见在调用知识点，我没有掌握好。不过，有了这次课程设计的经验和教训，我能够很清楚的对自己定一个合适的水平，而且在这次课程设计中我学会了运用两个新的函数sprintf和包涵在#include头文件中的输入函数。因为课程设计的题目是求最短路径，本来是想通过算法的实现把这个程序与交通情况相连，但是因为来不及查找各地的信息，所以，这个计划就没有实现，我相信在以后有更长时间的情况下，我会做出来的。

《数据结构》课程设计文档格式（定稿 篇六

课程设计报告的内容

设计结束后要写出课程设计报告，以作为整个课程设计评分的书面依据和存档材料。设计报告以规定格式的电子文档书写，打印并装订，排版及图，表要清楚，工整。 装订顺序如下:封面、目录、正文。正文包括以下7个内容:

1、需求分析

陈述说明程序设计的任务，强调的是程序要做什么 ，需要什么结果、所能达到的功能。

2、概要设计

说明本程序中用到的所有抽象数据类型的定义，主程序的流程以及各程序模块之间的层次（调用）关系。3.详细设计

实现概要设计中定义的所有数据类型，对每个操作只需要写出伪码算法；对主程序和其他模块也都需要写出伪码算法（伪码算法达到的详细程度建议为:按照伪码算法可以在计算机键盘直接输入高级程序设计语言程序）；可采用流程图、N S 图进行描述，画出函数和过程的调用关系图。

4、调试分析

内容包括:

a.调试过程中遇到的问题是如何解决的以及对设计与实现的回顾讨论和分析； b.算法的时空分析（包括基本操作和其他算法的时间复杂度和空间复杂度的分析）和 改进设想；

c.经验和体会等。5.测试结果

列出你的测试结果，包括输入和输出。这里的测试数据应该完整和严格，最好多于需求分析中所列。

6、参考文献

列出参考的相关资料和书籍。

封面格式如下：

数据结构课程设计报告

班级：_____ _____ _____ _________

姓名：____________________

指导教师：___________________

成绩：__________________________

信息工程学院

年月日

目录

1、需求分析 ………………………………………………

22．概要设计………………………………………………2

3、详细设计 ………………………………………………2

4、调试分析 ………………………………………………2

5、测试结果… ……………………………………………2 参考文献 …………………………………………………6

附录……………………………………………………

一、需求分析

二、概要设计

三、详细设计

四、调试分析

五、测试结果

六、参考文献

七、附录

附录为程序代码！4

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

通过两周的课程设计，完成了预定的目标，其中有很多的随想。老师的题目发下来的很早，大概提前了3周，当时就着手搜索有关线索二叉树的思想，思路，借了一本《数据结构-c语言描述》，在大体上就有了一个轮廓，先是输入二叉树，在对二叉树进行线索化，依次往下，但在具体实现时，遇到了很多问题：首先是思想的确定，其非常重要，以前有了这个想法，现在愈加清晰起来，因此，花了大量的时间在插入删除的具体操作设计上，大概三个晚上的时间，对其中什么不清晰明确之处均加以推敲，效果是显著的，在上机上相应的节约了时间。

通过具体的实验编码，思路是对的，但是在小问题上摔了一次又一次，大部分时间都是花在这方面，这个节点没传过来啊之类的，以后应该搞一个小册子，记录一些错误的集合，以避免再犯，思想与C语言联系起来，才是我们所需要的，即常说的理论与实践的关系。

数据结构是基础的一门课，对于有过编程经验的人，结合自己的编程体会去悟它的思想；而且我觉得随着编程经历的丰富对它的体会越深入，最初接触是对一些思想可能只是生硬的记忆，随着学习的深入逐渐领悟了很多。看了这次课程设计的题目，虽然具体要求没有看清，但是总结一下，可以看出，其需要我们能把一个具体案例或一件事情反映为程序来表达，数据结构就是桥梁，通过自己的设计，使应用能力得以融汇，对与问题，具有了初步的分析，继而解决之的能力，感觉对以后的学习会有很大的`帮助，学习无非是用于实践。

认识到自己的不足，希望能有进一步的发展。

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

一周的课程设计结束了，在这次的课程设计中不仅检验了我所学习的知识，也培养了我如何去把握一件事情，如何去做一件事情，又如何完成一件事情的方法和技巧。在设计过程中，和同学们相互探讨，相互学习，相互监督。我学会了运筹帷幄，学会了宽容，学会了理解，也学会了做人与处世，这次课程设计对我来说受益良多。

课程设计是我们专业课程知识综合应用的实践训练，着是我们迈向社会，从事职业工作前一个必不少的过程．“千里之行始于足下”，通过这次课程设计，我深深体会到这句千古名言的真正含义．我今天认真的进行课程设计，学会脚踏实地迈开这一步，就是为明天能稳健地在社会大潮中奔跑打下坚实的基础。

我这次设计的科目是数据结。

数据结构，是一门研究非数值计算的程序设计问题中计算机的操作对象（数据元素）以及它们之间的关系和运算等的学科，而且确保经过这些运算后所得到的新结构仍然是原来的结构类型。作为一门独立的课程在国外是从1968年才开始设立的。1968年美国唐欧克努特教授开创了数据结构的最初体系，他所著的《计算机程序设计技巧》第一卷《基本算法》是第一本较系统地阐述数据的逻辑结构和存储结构及其操作的著作。“数据结构”在计算机科学中是一门综合性的专业基础课。数据结构是介于数学、计算机硬件和计算机软件三者之间的一门核心课程。数据结构这一门课的内容不仅是一般程序设计（特别是非数值性程序设计）的基础，而且是设计和实现编译程序、操作系统、数据库系统及其他系统程序的重要基础。

通过这次模具设计，我在多方面都有所提高。

一、编译工具VisualC++

很多程序在结构上是独立的，但是本此设计的程序功能不是零散的，它有一个连接是的程序是一个整体，怎样达到这种统一体呢？因为这个输出连接是贯穿始终的。说到这，就应该说以下我所应用的调试工具，也就是运行环境VisualC++，可以充分利用Windows的支持剪贴版和英文的特点。正是在实现循环链表的程序中充分利用这个特点，才能制作出全汉化的初始化画面。

二、巩固和温习了C语言

在界面设置中使用函数调用while。其中文本显示颜色和背景颜色都可以任意按照自己的喜好，任意改变，但改变的时候必须采用标准英文大写，同时在制作显示菜单的窗口，大小根据菜单条数设计。最后采用printf输出程序设计界面。

这次的程序软件基本上运行成功，可以简单的建立链式循环链表，并进行输出，及循环语句的运用和选择语句的控制。由于时间和知识上的限制，使得程序规模相对较小，即功能还不很全面，应用也不很普遍。原来C语言可是涉及很多知识，而不是枯燥无聊的简单的代码部分而已，利用C语言方面的知识，我们可以设计出更完善的软件。

三、积累了宝贵的经验

我这次课程设计代码中主要使用了链表的循环和遍历这两中操作。循环链表（CircularLinkedList）是单链表的另一种形式，它是一个首尾相接的链表。其特点是将单链表最后一个结点的指针域由NULL改为指向头结点或线性表中的第一个结点，就得到了单链形式的循环链表，并称为循环单链表。类似地，还有多重链的循环链表。在循环单链表中，表中所有结点被链在一个环上，多重循环链表则是将表中的结点链在多个环上。为了使某些操作实现起来方便，在循环单链表中也可设置一个头结点。这样，空循环链表仅由一个自成循环的头结点表示。所谓遍历（Traversal），是指沿着某条搜索路线，依次对树中每个结点均做一次且仅做一次访问。访问结点所做的操作依赖于具体的应用问题。这次课程设计我选中的题目是个人资料的管理。编写了一个可以简易使用的个人资料管理系统，可以进行资料的输入和管理。虽然在我的程序中有一部分是从网上搜索得来的，但我已经竭力将所获得的信息变成自己的资源，动手上机操作，在了解和看懂的基础上有所改变和创新，但是在的程序软件中还有部分的不足，需要加以更新。仅管，我并没能很好的利用所学数据结构的知识，但我也尽了自己最大的努力用我所学来完成这次的课程设计。同时，通过这次课程设计，我认识到了自己动手实践的弱势，特别是在编程方面，知道了计算机的实践操作是很重要的，只有通过上机编程才能充分的了解自己的不足。

四、对以后的学习充满了信心和期待

通过这次的课程设计，更是让我深刻认识到自己在学习中的不足，同时也找到了克服这些不足的方法，这也是一笔很大的资源。在以后的时间中，我们应该利用更多的时间去上机实验，加强自学的能力，多编写程序，相信不久后我们的编程能力都会有很大的提高能设计出更多的更有创新的作品。

上面内容就是虎知道为您整理出来的8篇《数据结构课程设计心得体会》，希望对您的写作有所帮助。