数据结构课程设计-迷宫求解范文

时间:2019-05-14 02:23:29下载本文作者:会员上传
简介:写写帮文库小编为你整理了多篇相关的《数据结构课程设计-迷宫求解范文》,但愿对你工作学习有帮助,当然你在写写帮文库还可以找到更多《数据结构课程设计-迷宫求解范文》。

第一篇:数据结构课程设计-迷宫求解范文

数据结构课程设计

迷宫求解

学院:湖北工业大学计算机学院

教师:沈华老师

班级:12网络工程1班

学号:1210322118

姓名:饶进阳

时间:2013年12月22日

问题描述

.........................................................思路解析

.........................................................程序流程

.........................................................核心代码

.........................................................源程序代码........................................................程序运行实例.....................................................课设总结

.........................................................3 4 5 6 12 14 迷宫求解

问题描述:

可以输入一个任意大小的迷宫数据,用非递归的方法求出一条走出迷宫的路径,并将路径输出;

要求:

在上交资料中请写明:存储结构、基本算法(可以使用程序流程图)、源程序、测试数据和结果、算法的时间复杂度、另外可以提出算法的改进方法;

比如这是一个迷宫

电脑找出的出路

设定当前位置的初值为入口位置: do{

若当前位置可通,则{

将当前位置插入栈顶;} 若该位置是出口位置,则结束;

否则切换当前位置的东邻块为新的当前位置; 否则{

若栈不空且栈顶位置还有其他方向未被探索,则设定新的当前位置为沿顺时针方向旋转找到的栈顶位置的下一相邻块;} 若{ 栈不空但栈顶位置的四周均不可通,则删去栈顶位置;} 若{ 栈不空,则重新测试新的栈顶位置,直至找到一个可通的相邻块或出栈至栈空;} }while(栈不空){栈空说明没有路径存在}

PS:类似动态求解方法

程序流程

第一次用visio做程序框图,所以只把程序的大概流程画出来了。

核心代码

//栈相关操作 int initlStack(Stack *S)int pushStack(Stack S, coordinate e)int popStack(Stack S, coordinate *e)int getTop(Stack S, coordinate *e)void show(Stack S)

//创建一个迷宫 int creatMaze(Maze *m)

//打印出一个迷宫 void showMaze(Maze *m)

//求当前结点的下一个通路

coordinate passNext(Maze *m, int i, int j)//求迷宫路径

int solveMaze(Maze *m, Stack S)//模拟出路径

void showRoad(Maze m, Stack S)

程序源码:

#include #include

#define MAX 100

#define SIZE sizeof(Node)//**************************** //栈

typedef struct { int x;//行

int y;//列 }coordinate;//坐标

typedef struct node{ coordinate data;struct node *next;}Node, *Stack;

//栈的相关操作

//栈初始化

//带头结点的链栈

int initlStack(Stack *S){(*S)=(Node *)malloc(SIZE);if((*S)== NULL){

return 1;}(*S)->next = NULL;return 0;}

//入栈

int pushStack(Stack S, coordinate e){ Node *p;

p =(Node *)malloc(SIZE);p->data.x = e.x;p->data.y = e.y;p->next = S->next;S->next = p;return 0;}

//出栈

int popStack(Stack S, coordinate *e){ Node *p;if(S->next == NULL){

printf(“nStack is empty!n”);

return 2;} e->x = S->next->data.x;e->y = S->next->data.y;p = S->next;S->next = p->next;free(p);return 0;}

//读取栈顶

int getTop(Stack S, coordinate *e){ e->x = S->next->data.x;e->y = S->next->data.y;return 0;}

//显示

void show(Stack S){ Node *p;p = S->next;while(p!= NULL){

printf(“%d %d <-”, p->data.x, p->data.y);

p = p->next;} printf(“startn”);} //***************************

//*************************** //迷宫

typedef struct { int row;int col;int arr[MAX][MAX];}Maze;

//创建一个迷宫

int creatMaze(Maze *m){ int i, j;printf(“nplease input Maze's row and col:n”);scanf(“%d%d”, &(m->row), &(m->col));printf(“nplease input the Maze's message:(0 is ok),(1 is no)n”);for(i = 0;i <= MAX1;j++){

m->arr[i][j] = 1;

} } for(i = 1;i <= m->row;i++){

for(j = 1;j <= m->col;j++){

scanf(“%d”, &(m->arr[i][j]));

} } return 0;}

//显示迷宫信息

void showMaze(Maze *m){ int i, j;printf(“nthe Maze you hava input:n”);for(i = 1;i <= m->row;i++){

for(j = 1;j <= m->col;j++){

printf(“%d ”, m->arr[i][j]);

}

printf(“n”);}

printf(“nlike this:n”);for(i = 1;i <= m->row;i++){

for(j = 1;j <= m->col;j++){

if(m->arr[i][j]!= 0){

printf(“■ ”);

}

else {

printf(“□ ”);

}

}

printf(“n”);} } //求当前结点的下个通路 //顺时针找

coordinate passNext(Maze *m, int i, int j){ coordinate k;if(m->arr[i][j+1] == 0){//东

k.x = i;

k.y = j+1;

return k;}

if(m->arr[i+1][j] == 0){//南

k.x = i+1;

k.y = j;

return k;} if(m->arr[i][j-1] == 0){//西

k.x = i;

k.y = j-1;

return k;} if(m->arr[i-1][j] == 0){//北

k.x = i-1;

k.y = j;

return k;} else {//不存在 k.x =-1;

k.y =-1;

return k;} }

//求解迷宫

int solveMaze(Maze *m, Stack S){ int i, j;int boolean;coordinate a;i = 1;j = 1;do {

if(m->arr[i][j] == 0){

a.x = i;

a.y = j;

m->arr[i][j] = 2;

pushStack(S, a);

if(i == m->row && j == m->col){

return 0;

}

}

a = passNext(m, i, j);

if(a.x!=-1){

i = a.x;

j = a.y;

continue;

}

else if(a.x ==-1){

boolean = popStack(S, &a);

if(2 == boolean){

return 0;

}

getTop(S, &a);

i = a.x;

j = a.y;

} }while(S->next!= NULL);return 0;}

//模拟出路径

void showRoad(Maze m, Stack S){ coordinate e;int i, j;if(S->next == NULL){

printf(“nSorry!you can't go out the Maze!n”);} while(S->next!= NULL){

popStack(S, &e);

m.arr[e.x][e.y] =-1;} for(i = 1;i <= m.row;i++){

for(j = 1;j <= m.col;j++){

if(m.arr[i][j] >= 0){

printf(“■ ”);

}

else {

printf(“□ ”);

}

}

printf(“n”);} } //*************************** //主函数 int main(){ Maze m;Stack S;printf(“※ 欢迎玩耍迷宫求解游戏 ※n”);initlStack(&S);creatMaze(&m);showMaze(&m);solveMaze(&m, S);printf(“nthe root is here:n”);show(S);showRoad(m, S);return 0;}

程序运行结果:

第一步:输入迷宫行列大小

第二步:输入迷宫信息

第四步:程序会自动求出路径

课 设 总 结

敬爱的沈华老师您好,感谢您这半年对我们的教诲,说实话,很喜欢上您的课,您上课的风采深深的吸引了我,每次上您的课,我都听得特别认真。好吧,言归正传,谈谈这次课程设计的感想。

首先看到这道题的时候,真心没多少思路,我抱着试一试的态度,去网上搜索相关的算法。网上资源蛮多的,刚开始就搜索到了,严蔚敏老师的相关算法讲解视频,虽然她讲的是思想(就是他并没有源程序的实现),但是足够让我理解了基本算法流程。

其实先开始都不知道怎么下笔,但是我还是想着从基本栈开始写吧,慢慢写着,程序大概思想框架就成型了,最后在实现求解迷宫路径的时候,着手用笔在草稿纸上面模拟,然后才敲到编译器中,最好几经调试,终于得到了想要的结果。

做完这次课设后,深刻的体会到一些道理,在信息时代,解决问题的最好方法是运用现代的信息资源。并且在实际中,开始没思路的事,慢慢完成小部分,那么你的总体思维会渐渐地成型。

做事做人,平心气和的干,总会得到成功!

第二篇:数据结构课程设计 背包问题的求解

2009届 电子信息科学与技术专业 数据结构课程设计

背包问题的求解

摘要 组合优化问题的求解方法研究已经成为了当前众多科学关注的焦点,这不仅在于其内在的复杂性有着重要的理论价值,同时也在于它们能在现实生活中广泛的应用。背包问题是一个典型的组合优化问题,本课程设计用递归算法求解背包问题,就是在资源有限的条件下,追求总的最大收益的资源有效分配问题。关键词 背包问题;

递归算法;

1问题描述

1.1问题描述

背包问题:设有不同价值、不同重量的物品n件,求从这n件物品中选取一部分的方案,使选中物品的总重量不超过指定的限制重量,但选中物品的价值之和最大。

1.2基本思想

(1)分别输入n件物品的重量和价值。(2)采用递归寻找物品的方案。

(3)输出最佳的装填方案,包括选中的是哪几种物品,总价值为多少。

2问题分析

背包问题的求解是一个很经典的案例。对于它的分析与研究已经到达了一定的深度,解决这个问题有很多很多的办法。其中递归方法是比较简化程序,也比较难理解的一个。

设n件物品的重量分别为w0,w1,„,wn-1,物品的价值分别为v0,v1,„,vn-1。采用递归寻找物品的选择方案。设前面已经有了多种选择方案,并保留了其中最大的选择方案于数组option[],设方案的的总价值存于变量maxv,当前正在考察新方案其物品选择情况保存于数组cop[],嘉定当前方案已经考虑了前i-1件物品,现在正在考虑第i件物品;当前方案已经包含的物品的质量之和为tw;至此,若其余物品都选择可能的话,本方案能达到的总价值的期望值设为tv,算法引入tv是当一旦当前方案的总价值的期望值也小于前面方案的总价值maxv时,急需考察当前方案变成无意义的工作,应终止当前方案,立即去考察下一个方案。因为当方案的总价值不比maxv大时,该方案不会不会再被考察。这同时保证函数后找到的方案一定会比前面的方案更好。2009届 电子信息科学与技术专业 数据结构课程设计 对于第i件物品的选择有两种可能:

(1)物品i被选择,这种可能性仅当包含它不会超过方案总重量的限制时才是可行的。选中后,继续递归去考虑其余物品的选择;

(2)物品i不被选择,这种可能性仅当不包物品i也有可能会找大价值更大的方案的情况。

就此,通过不断地对从第一件开始的物品到第n件物品进行选择或是不选择,从而从各个方案的比较中选择出最优方案。

采用option[]和cop[]两个数组,来辅助完成递归寻找物品的选择方案。数组option[]起到一个“旗帜”作用,用来区别于未被选择的物品,从而达到输出被选择的函数。而cop[]则像是一个中间变量,它在递归过程中不断地发生变化,将有效的最终数据传输给数组option[],起到一个桥梁作用。

3数据结构描述

背包问题结构体:

struct{

int weight;

int value;

}a[N];4算法设计

4.1程序流程图

2009届 电子信息科学与技术专业 数据结构课程设计

图4-1 程序流程图

4.2算法设计

根据问题分析中的思想写出递归算法如下:

find(物品当前选择已达到的重量和tw,本方案可能达到的总价值为tv){

/*考虑物品i包含在当前方案中的可能性*/ if(包含物品i是可接受的){

将物品i包含在当前方案中;

if(i

以当前方案作为临时最佳方案保存;

恢复物品i不包含状态;

} 2009届 电子信息科学与技术专业 数据结构课程设计

/*考虑物品i不包含在当前方案中的可能性*/ if(不包含物品i仅是可考虑的)

if(i

以当前方案作为临时最佳方案保存;

void find(int i,int tw,int tv)

{ int k;if(tw+a[i].weight<=limitw)

/*物品i包含在当前方案的可能性*/ { cop[i]=1;if(imaxv)

/*物品i不包含在当前方案的可能性*/ if(i

opion[k]=cop[k];maxv=tv-a[i].value;} } 5详细程序清单

详细程序清单见附录。

6程序运行结果

背包问题求解界面如图6-1所示。

图6-1 背包问题求解界面

程序调试成功。

在课程设计代码调试过程中也出了不少差错,比如头文件很容易忽略,同学指出才发现;一些符号像“;”也很容易丢掉或是中英文格式不正确;甚至像0和 O这种小错误有时也会发生,在经过调试和完善程序的过程中,这些错误已经全部改正。在此过程中我们学到了不少调试的技巧,极大得丰富了编程的知识,这些在程序的优化方面帮助很大。

7心得体会

通过此次课程设计的实践,感触较深。不仅使我们加深了对书本知识的理解,而且锻炼了我们编写程序、调试程序的能力。同时,此次课程设计也充分弥补了课堂教学中知识的缺陷。这次课程设计由于时间有限,对有些地方考虑的还不够周到。

2009届 电子信息科学与技术专业 数据结构课程设计

在本课题中,我们研究了如何用递归算法求解组合优化问题中的背包问题,背包问题是一个典型的组合优化问题,就是在资源有限的条件下,追求总的最大收益的资源有效分配问题。所以我们试着用所学的数据结构知识以及递归法来解决普通的背包问题。背包问题的递归思想确实有点难以理解,为了理解这个思想,我们确实花了很长时间,不过很高兴最后经过我们的讨论掌握了这个思想。

参考文献

[1] 徐孝凯.数据结构课程实验.北京:清华大学出版社,2002:100-132 [2] 张乃笑.数据结构与算法.北京:电子工业出版,2000:3-5 [3] 严蔚敏.数据结构(C语言版).北京: 清华大学出版社,2002:100-132 [4] 李春葆.数据结构(C语言篇)习题与解析(修订版).北京:清华大学出版,2000:45-66

Knapsack problem solving

Li Shuai Zhu Zhili Kong Rongong(Department of Physics ,Dezhou University,Dezhou,253023)Abstract Combinatorial optimization problem solving method has become the focus of attention of the scientific, it not only lies in its inherent complexity has the important theoretical value, but also that they can in real life widely.Knapsack problem is a typical combinatorial optimization problem, the course is designed to use recursion algorithm for solving knapsack problem was under the condition of limited resources, the pursuit of the maximum benefit of the resources allocation problem.Keywords knapsack problem;recursive algorithm 2009届 电子信息科学与技术专业 数据结构课程设计

附录:详细程序清单

#include #define N 100 int limitw,/*限制的总重量*/ totv,/*全部物品的总价*/ maxv;

/*可实现最大总价值*/ int opion[N],cop[N];

struct{

int weight;

int value;

}a[N];int n;

void find(int i,int tw,int tv)

{ int k;if(tw+a[i].weight<=limitw)

{ cop[i]=1;if(i

/*方案的选择*/ /*当前方案的选择*/ /*背包问题结构体*/

/*物品种数*/ /*物品i包含在当前方案的可能性*/ 7

2009届 电子信息科学与技术专业 数据结构课程设计

if(tv-a[i].value>maxv)

/*物品i不包含在当前方案的可能性*/ if(i

第%d种物品(重量,价值):”,k+1);scanf(“%d,%d”,&w,&v);a[k].weight=w;a[k].value=v;totv+=v;} printf(“背包所能承受的总重量:”);scanf(“%d”,&limitw);maxv=0;for(k=0;k

printf(“最佳装填方案是:n”);for(k=0;k

第三篇:数据结构迷宫问题实验报告

《数据结构与算法设计》

迷宫问题实验报告

——实验二

专业:物联网工程 班级:物联网1班 学号:15180118 姓名:刘沛航

一、实验目的

本程序是利用非递归的方法求出一条走出迷宫的路径,并将路径输出。首先由用户输入一组二维数组来组成迷宫,确认后程序自动运行,当迷宫有完整路径可以通过时,以0和1所组成的迷宫形式输出,标记所走过的路径结束程序;当迷宫无路径时,提示输入错误结束程序。

二、实验内容

用一个m*m长方阵表示迷宫,0和1分别表示迷宫中的通路和障碍。设计一个程序对于任意设定的迷宫,求出一条从入口到出口的通路,或得出没有通路的结论。

三、程序设计

1、概要设计

(1)设定栈的抽象数据类型定义

ADT Stack{

数据对象:D={ai|ai属于CharSet,i=1、2…n,n>=0} 数据关系:R={|ai-1,ai属于D,i=2,3,…n} 基本操作: InitStack(&S)

操作结果:构造一个空栈 Push(&S,e)

初始条件:栈已经存在

操作结果:将e所指向的数据加入到栈s中 Pop(&S,&e)

初始条件:栈已经存在

操作结果:若栈不为空,用e返回栈顶元素,并删除栈顶元素 Getpop(&S,&e)

初始条件:栈已经存在

操作结果:若栈不为空,用e返回栈顶元 StackEmpty(&S)

初始条件:栈已经存在

操作结果:判断栈是否为空。若栈为空,返回1,否则返回0 Destroy(&S)

初始条件:栈已经存在 操作结果:销毁栈s }ADT Stack

(2)设定迷宫的抽象数据类型定义

ADT yanshu{

数据对象:D={ai,j|ai,j属于{‘ ’、‘*’、‘@’、‘#’},0<=i<=M,0<=j<=N} 数据关系:R={ROW,COL}

ROW={|ai-1,j,ai,j属于D,i=1,2,…M,j=0,1,…N} COL={|ai,j-1,ai,j属于D,i=0,1,…M,j=1,2,…N} 基本操作:

InitMaze(MazeType &maze, int a[][COL], int row, int col){

初始条件:二维数组int a[][COL],已经存在,其中第1至第m-1行,每行自第1到第n-1列的元素已经值,并以值0表示障碍,值1表示通路。

操作结果:构造迷宫的整形数组,以空白表示通路,字符‘0’表示障碍

在迷宫四周加上一圈障碍

MazePath(&maze){

初始条件:迷宫maze已被赋值

操作结果:若迷宫maze中存在一条通路,则按如下规定改变maze的状态;以字符‘*’表示路径上的位置。字符‘@’表示‘死胡同’;否则迷宫的状态不变 }

PrintMaze(M){ 初始条件:迷宫M已存在 操作结果:以字符形式输出迷宫 }

}ADTmaze

(3)本程序包括三个模块

a、主程序模块 void main(){ 初始化; 构造迷宫; 迷宫求解; 迷宫输出; }

b、栈模块——实现栈的抽象数据类型 c、迷宫模块——实现迷宫的抽象数据类型

2、详细设计

(1)坐标位置类型:

typedef struct{ int row;//迷宫中的行 int col;//......的列

}PosType;//坐标

(2)迷宫类型:

typedef struct{ int m,n;int arr[RANGE][RANGE];}MazeType;//迷宫类型

void InitMaze(MazeType &maze, int a[][COL], int row, int col)//设置迷宫的初值,包括边缘一圈的值

Bool MazePath(MazeType &maze,PosType start, PosType end)//求解迷宫maze中,从入口start到出口end的一条路径 //若存在,则返回true,否则返回false Void PrintMaze(MazeType maze)//将迷宫打印出来

(3)栈类型:

typedef struct{ int step;//当前位置在路径上的“序号” PosType seat;//当前的坐标位置

DirectiveType di;//往下一个坐标位置的方向 }SElemType;//栈的元素类型

typedef struct{ SElemType *base;SElemType *top;int stacksize;}SqStack;栈的基本操作设置如下: Void InitStack(SqStack & S)

//初始化,设S为空栈(S.top=NUL)Void DestroyStack(Stack &S)//销毁栈S,并释放空间

Void ClearStack(SqStack & S)//将栈S清空

Int StackLength(SqStack &S)//返回栈S的长度

Status StackEmpty(SqStack &S)?、若S为空栈(S.top==NULL),则返回TRUE,否则返回FALSE Statue GetTop(SqStack &S,SElemType e)

//r若栈S不空,则以e待会栈顶元素并返回TRUE,否则返回FALSE Statue Pop(SqStack&S,SElemType e)//若分配空间成功,则在S的栈顶插入新的栈顶元素s并返回TRUE //否则栈不变,并返回FALSE Statue Push(SqStack&S,SElemType &e)//若分配空间程控,则删除栈顶并以e带回其值,则返回TRUE //否则返回FALSE Void StackTraverse(SqStack &S,Status)(*Visit)(SElemType e))//从栈顶依次对S中的每个节点调用函数Visit 4求迷宫路径的伪码算法:

Status MazePath(MazeType &maze,PosType start, PosType end){ //求解迷宫maze中,从入口start到出口end的一条路径 InitStack(s);PosType curpos = start;int curstep = 1;//探索第一部 do{ if(Pass(maze,curpos)){ //如果当前位置可以通过,即是未曾走到的通道块 FootPrint(maze,curpos);//留下足迹

e = CreateSElem(curstep,curpos,1);//创建元素 Push(s,e);if(PosEquare(curpos,end))return TRUE;curpos =NextPos(curpos,1);//获得下一节点:当前位置的东邻 curstep++;//探索下一步 }else{ //当前位置不能通过 if(!StackEmpty(s)){ Pop(s,e);while(e.di==4 &&!StackEmpty(s)){ MarkPrint(maze,e.seat);Pop(s,e);//留下不能通过的标记,并退回步 } if(e.di<4){ e.di++;Push(s,e);//换一个方向探索

curpos = NextPos(e.seat,e.di);//设定当前位置是该方向上的相块 }//if }//if }//else }while(!StackEmpty(s));return FALSE;} //MazePath

四、程序调试分析

1.首先呢,想自己读入数据的,回来发现那样,很麻烦,所以还是事先定义一个迷宫。

2.栈的元素类型 一开始有点迷惑,后来就解决了

3.本题中三个主要算法;InitMaze,MazePath和PrintMaze的时间复杂度均为O(m*n)本题的空间复杂度也是O(m*n)

五、用户使用说明

1.本程序运行在windows系列的操作系统下,执行文件为:Maze_Test.exe。

六、程序运行结果

1.建立迷宫: 2.通过1功能建立8*8的迷宫后,通过2功能继续建立迷宫内部:

通过建立自己设定单元数目建立迷宫内墙。3.通过3功能观察已建立的迷宫结构:

4.通过4功能确立迷宫起点和终点:

(此处像我们随机选择4,4和2,7分别为起点终点)

5.执行5功能,判断是否有路径走出迷宫:

这种情况无法走出迷宫。

我们再次观察图像设4,4和1,6分别为起点终点,再运行5功能。

观察到可以成功解开迷宫步数从1依次开始。

七、程序清单

#include #include #include #include // 迷宫坐标位置类型 typedef struct { int x;int y;}PosType;// 行值

// 列值

#define MAXLENGTH 25 // 设迷宫的最大行列为25

typedef int MazeType[MAXLENGTH][MAXLENGTH];// 迷宫数组[行][列]

typedef struct // 栈的元素类型

{ int ord;// 通道块在路径上的"序号"

PosType seat;// 通道块在迷宫中的"坐标位置"

int di;// 从此通道块走向下一通道块的"方向"(0~3表示东~北)}SElemType;

// 全局变量

MazeType m;// 迷宫数组

int curstep=1;// 当前足迹,初值为1

#define STACK_INIT_SIZE 10 // 存储空间初始分配量

#define STACKINCREMENT 2 // 存储空间分配增量

// 栈的顺序存储表示

typedef struct SqStack { SElemType *base;// 在栈构造之前和销毁之后,base的值为NULL

SElemType *top;

int stacksize;

// 构造一个空栈S int InitStack(SqStack *S){ // 为栈底分配一个指定大小的存储空间

(*S).base =(SElemType *)malloc(STACK_INIT_SIZE*sizeof(SElemType));if(!(*S).base)

(*S).top =(*S).base;

return 1;

// 栈底与栈顶相同表示一个空栈

(*S).stacksize = STACK_INIT_SIZE;exit(0);}SqStack;// 顺序栈

// 栈顶指针

// 当前已分配的存储空间,以元素为单位 }

// 若栈S为空栈(栈顶与栈底相同的),则返回1,否则返回0。int StackEmpty(SqStack S){ if(S.top == S.base)

else

}

// 插入元素e为新的栈顶元素。int Push(SqStack *S, SElemType e){ if((*S).top-(*S).base >=(*S).stacksize)// 栈满,追加存储空间

{

} *((*S).top)++=e;return 1;} // 若栈不空,则删除S的栈顶元素,用e返回其值,并返回1;否则返回0。int Pop(SqStack *S,SElemType *e){ if((*S).top ==(*S).base)

return 1;} // 定义墙元素值为0,可通过路径为1,不能通过路径为-1,通过路径为足迹 // 当迷宫m的b点的序号为1(可通过路径),return 1;否则,return 0。int Pass(PosType b){

if(m[b.x][b.y]==1)

else return 0;return 1;return 0;*e = *--(*S).top;

// 这个等式的++ * 优先级相同,但是它们的运算方式,是自右向

(*S).base =(SElemType *)realloc((*S).base ,(*S).top =(*S).base+(*S).stacksize;(*S).stacksize += STACKINCREMENT;((*S).stacksize + STACKINCREMENT)* sizeof(SElemType));exit(0);if(!(*S).base)return 0;return 1;}

void FootPrint(PosType a)

// 使迷宫m的a点的序号变为足迹(curstep),表示经过 { m[a.x][a.y]=curstep;}

// 根据当前位置及移动方向,返回下一位置

PosType NextPos(PosType c,int di){ PosType direc[4]={{0,1},{1,0},{0,-1},{-1,0}};// {行增量,列增量}

// 移动方向,依次为东南西北

c.x+=direc[di].x;c.y+=direc[di].y;return c;}

// 使迷宫m的b点的序号变为-1(不能通过的路径)void MarkPrint(PosType b){

m[b.x][b.y]=-1;} // 若迷宫maze中存在从入口start到出口end的通道,则求得一条

// 存放在栈中(从栈底到栈顶),并返回1;否则返回0 int MazePath(PosType start,PosType end){

SqStack S;PosType curpos;SElemType e;

InitStack(&S);curpos=start;do {

if(Pass(curpos)){// 当前位置可以通过,即是未曾走到过的通道块

FootPrint(curpos);// 留下足迹

e.ord=curstep;e.seat.x=curpos.x;e.seat.y=curpos.y;e.di=0;Push(&S,e);// 入栈当前位置及状态

curstep++;// 足迹加1

if(curpos.x==end.x&&curpos.y==end.y)// 到达终点(出口)

} else return 1;curpos=NextPos(curpos,e.di);{// 当前位置不能通过

} if(!StackEmpty(S)){

} Pop(&S,&e);// 退栈到前一位置

curstep--;while(e.di==3&&!StackEmpty(S))// 前一位置处于最后一个方向(北){

} if(e.di<3)// 没到最后一个方向(北){

}

e.di++;// 换下一个方向探索

Push(&S,e);curstep++;// 设定当前位置是该新方向上的相邻块 curpos=NextPos(e.seat,e.di);

MarkPrint(e.seat);// 留下不能通过的标记(-1)Pop(&S,&e);// 退回一步

curstep--;}while(!StackEmpty(S));return 0;}

// 输出迷宫的结构

void Print(int x,int y){

int i,j;

for(i=0;i

} }

void main(){ PosType begin,end;int i,j,x,y,x1,y1,n,k;for(j=0;j

//清屏函数

printf(“***************************************************nnn”);printf(“

1请输入迷宫的行数,列数n”);printf(“

2请输入迷宫内墙单元数n”);printf(“

3迷宫结构如下n”);printf(“

4输入迷宫的起点和终点n”);printf(“

5输出结果n”);printf(“

0退出n”);printf(“nn请选择

”);scanf(“%d”,&n);switch(n){ case 1:{

printf(“请输入迷宫的行数,列数(包括外墙):(空格隔开)”);

scanf(“%d%d”, &x, &y);

for(j=1;j

{

for(i=1;i

for(j=1;j

// 迷宫左边列的周边即左边墙

m[j][y-1]=0;// 迷宫右边列的周边即右边墙

for(i=0;i

// 迷宫上面行的周边即上边墙

m[x-1][i]=0;// 迷宫下面行的周边即下边墙

-15180118-刘沛

}

}break;

case 2:

{printf(“请输入迷宫内墙单元数:”);

scanf(“%d”,&j);

printf(“请依次输入迷宫内墙每个单元的行数,列数:(空格隔开)n”);

for(i=1;i<=j;i++)

{ scanf(“%d%d”,&x1,&y1);

} m[x1][y1]=0;

}break;

case 3:{ Print(x,y);printf(“刘沛航建立的迷宫,定义墙元素值为0,可通过路径为1,输入0退出”);scanf(“%d”,&k);}break;

case 4:{ printf(“请输入起点的行数,列数:(空格隔开)”);

scanf(“%d%d”,&begin.x,&begin.y);

printf(“请输入终点的行数,列数:(空格隔开)”);

scanf(“%d%d”,&end.x,&end.y);}break;

case 5:{

if(MazePath(begin,end))// 求得一条通路

{

} else printf(“此迷宫没有从入口到出口的路径,谢谢使用刘沛航的程序n”);printf(“输入0退出”);scanf(“%d”,&k);}break;} }while(n!=0);} printf(“此迷宫从入口到出口的一条路径如下,谢谢使用刘沛航的程序:n”);Print(x,y);// 输出此通路

第四篇: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 #include typedef 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 #include typedef 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->data.English);

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

运行界面如下:

下载数据结构课程设计-迷宫求解范文word格式文档
下载数据结构课程设计-迷宫求解范文.doc
将本文档下载到自己电脑,方便修改和收藏,请勿使用迅雷等下载。
点此处下载文档

文档为doc格式


声明:本文内容由互联网用户自发贡献自行上传,本网站不拥有所有权,未作人工编辑处理,也不承担相关法律责任。如果您发现有涉嫌版权的内容,欢迎发送邮件至:645879355@qq.com 进行举报,并提供相关证据,工作人员会在5个工作日内联系你,一经查实,本站将立刻删除涉嫌侵权内容。

相关范文推荐

    《数据结构》课程设计文档格式(定稿)

    课程设计报告的内容设计结束后要写出课程设计报告,以作为整个课程设计评分的书面依据和存档材料.设计报告以规定格式的电子文档书写,打印并装订,排版及图,表要清楚,工整. 装......

    课程设计(数据结构)

    课程设计题目 1、 运动会分数统计 任务:参加运动会有n个学校,学校编号为1……n。比赛分成m个男子项目,和w个女子项目。项目编号为男子1……m,女子m+1……m+w。不同的项目取前五......

    数据结构课程设计

    数据结构课程设计 计算机科学与技术2008级1班 课程设计题目:图书借阅管理系统 姓名: 学号: 一.需求分析说明 图书借阅处理过程简述处理过程主要包含:新增图书上架、办理图证、图......

    数据结构课程设计

    课 程 设 计 任 务 书 信息 学院 信息管理与信息系统 专业 09级1班 班 孙鹏一、 二、 课程设计题目: 迷宫求解、一元多项式 课程设计主要参考资料: 数据结构(C语言版) 严蔚敏、......

    数据结构课程设计

    《数据结构》 课程设计报告 学 号 姓 名 班 级 指导教师 XXX XXX XXX XXX 安徽工业大学计算机学院 2014年6月 利用栈实现迷宫问题的求解 一、问题描述 以一个M*N的长方阵表......

    数据结构课程设计

    南京航空航天大学金城学院 《数据结构》 课程设计报告 题目:一元多项式的加减乘法运算 班级: 20100232 学号: 2010023220 姓名: 祁博 成绩:指导教师: 叶延风完成日期: 2012年 2月18......

    数据结构课程设计

    河海大学计算机与信息学院(常州)数据结构课程设计 课程设计题目: 多 项 式 问 题专业 、 年级:计算机科学与技术09级 学 号: 0962810226 姓 名: 王超目 录 一、问题描述----------......

    数据结构课程设计

    一、课程题目:一元稀疏多项式计算器 二、需求分析 1、一元稀疏多项式简单计算器的功能是: 1.1 输入并建立多项式; 1.2 输出多项式,输出形式为整数序列:n,c1,e1,c2,e2,„„„cn,en,......