c语言数据结构（考题，测试你的能力）－－编写源代码
Posted
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了c语言数据结构（考题，测试你的能力）－－编写源代码相关的知识，希望对你有一定的参考价值。
一。构造动态分配顺序存储的线性表，并在其上实现以下操作：
1.ListInsert(&L,i,e)在L中第i个位置前插入e
2.ListDelete(&L,i,&e)删除L中的第i个元素，用e返回其值。
3.PrintList(L)输出线性表中所有元素
二 构造线性链表，并在其上实现下列操作
1.LocateElem（L,e,compare()）返回L中第一个于e满足compare()关系的元素的地址，若不存在则返回NULL
2.ListLenth（L）求表长
3.PrintList(L)输出链表中各结点值
三。构造一个顺序栈，并在其上实现以下操作：
1.push(&S,e)插入元素e为新的栈顶
2.post(&S,&e)删除栈顶元素并用e返回
3.GetTop(S,&e)用e返回栈顶元素
四。构造顺序存储的循环队列，并实现
1.EnQueue(&Q,e)插入元素e为新的队尾
2.DeQueue(&Q,&e)删除队头元素，并用e返回
3.QueueLength(Q)求队列长度
五。生成于串常量s相等的，一堆分配存储的串，并实现
1.Concat(&T,S1,S2)将s1和s2连接为新串T
2.substring(S,pos,len)返回S中pos开始的长度为len的子串
六。输入一个稀疏矩阵，以三元组顺序存储，并实现以下操作
1.TranspoSeMatrix(M,&T)将M转制为T
2.Fast TranposESMatrix(M,&T)使用快速转置方法将M转置为T
七。以二叉链表为存储结构构造一棵二叉树，并借助栈实现其非递归的中序遍历算法。
八。构造一个以邻接矩阵为存储结构的无向图，并实现其深度优先搜索算法
九。构造一个以邻接表为存储结构的无向图，并实现其深度优先搜索算法
十。以45 24 64 56 12 25 90 为查找关键字序列，生成以二叉链表为存储结构的二叉排序树，并以 中序遍历序列输出树中的各关键字
十一. 以 19 14 23 1 68 20 84 27 55 11 10 79 为关键字，按哈希函数H(key)=key mod 13 和链表地址法处理冲突构造哈希表，并实现：search(L,x)在表中查找关键字x的操作
十二.建立顺序表，并在其上实现
1.直接插入排序
2.希尔排序
3.快速排序
答案：http://hi.baidu.com/wlgczjz
/*假设ha为A稀疏矩阵十字链表的头指针，hb为B稀疏矩阵十字链表的头指针*/
#include<stdio.h>
#define maxsize 100
struct linknode
int i,j;
struct linknode *cptr,*rptr;
union vnext
int v;
struct linknode *next; k;
;
struct linknode creatlindmat( ) /*建立十字链表*/
int x, m, n, t, s, i, j, k;
struct linknode *p , *q, *cp[maxsize],*hm;
printf("请输入稀疏矩阵的行、列数及非零元个数\n");
scanf("%d%d%d",&m,&n,&t);
if (m>n) s=m; else s=n;
hm=(struct linknode*)malloc(sizeof(struct linknode)) ;
hm->i=m; hm->j=n;
cp[0]=hm;
for (i=1; i<=s;i++)
p=(struct linknode*)malloc(sizeof(struct linknode)) ;
p->i=0; p->j=0;
p->rptr=p; p->cptr=p;
cp[i]=p;
cp[i-1]->k.next=p;
cp[s]->k.next=hm;
for( x=1;x<=t;x++)
printf("请输入一个三元组(i,j,v)\n");
scanf("%d%d%d",&i,&j,&k);
p=(struct linknode*)malloc(sizeof(struct linknode));
p->i=i; p->j=j; p->k.v=k;
/*以下是将p插入到第i行链表中 */
q=cp[i];
while ((q->rptr!=cp[i]) &&( q->rptr->j<j))
q=q->rptr;
p->rptr=q->rptr;
q->rptr=p;
/*以下是将P插入到第j列链表中*/
q=cp[j];
while((q->cptr!=cp[j]) &&( q->cptr->i<i))
q=q->cptr;
p->cptr=q->cptr;
q->cptr=p;
return hm;
/* ha和hb表示的两个稀疏矩阵相加，相加的结果放入ha中*/
struct linknode *matadd(struct linknode *ha, struct linknode *hb)
struct linknode *pa, *pb, *qa, *ca,*cb,*p,*q;
struct linknode *hl[maxsize];
int i , j, n;
if((ha->i!=hb->i)||(ha->j!=hb->j))
printf("矩阵不匹配,不能相加\n");
else
p=ha->k.next; n=ha->j;
for (i=1;i<=n; i++)
hl[i]=p;
p=p->k.next;
ca=ha->k.next; cb=hb->k.next;
while(ca->i==0)
pa=ca->rptr; pb=cb->rptr;
qa=ca;
while(pb->j!=0)
if((pa->j<pb->j)&&(pa->j!=0))
qa=pa; pa=pa->rptr;
else if ((pa->j>pb->j)||(pa->j==0)) /*插入一个结点*/
p=(struct linknode*)malloc(sizeof(struct linknode));
p->i=pb->i; p->j=pb->j;
p->k.v=pb->k.v;
qa->rptr=p; p->rptr=pa;
qa=p; pb=pb->rptr;
j=p->j; q=hl[j]->cptr;
while((q->i<p->i)&&(q->i!=0))
hl[j]=q; q=hl[j]->cptr;
hl[j]->cptr=p; p->cptr=q;
hl[j]=p;
else
pa->k.v=pa->k.v+pb->k.v;
if(pa->k.v==0) /*删除一个结点*/
qa->rptr=pa->rptr;
j=pa->j; q=hl[j]->cptr;
while (q->i<pa->i)
hl[j]=q; q=hl[j]->cptr;
hl[j]->cptr=q->cptr;
pa=pa->rptr; pb=pb->rptr;
free(q);
else
qa=pa; pa=pa->rptr;
pb=pb->rptr;
ca=ca->k.next; cb=cb->k.next;
return ha;
void print(struct linknode *ha) /*输出十字链表*/
struct linknode *p,*q;
p=ha->k.next;
while(p->k.next!=ha)
q=p->rptr;
while(q->rptr!=p)
printf("%3d%3d%3d\t",q->i,q->j,q->k.v);
q=q->rptr;
if(p!=q)
printf("%3d%3d%3d",q->i,q->j,q->k.v);
printf("\n");
p=p->k.next;
q=p->rptr;
while(q->rptr!=p)
printf("%3d%3d%3d\t",q->i,q->j,q->k.v);
q=q->rptr;
if(p!=q)
printf("%3d%3d%3d",q->i,q->j,q->k.v);
printf("\n");
void main()
struct linknode *ha=NULL,*hb=NULL,*hc=NULL;
ha=creatlindmat( ); /*生成一个十字链表ha*/
hb=creatlindmat( ); /*生成另一个十字链表hb*/
printf("A:\n"); /*输出十字链表ha*/
print(ha);printf("\n");
printf("B:\n"); /*输出十字链表hb*/
print(hb);printf("\n");
hc=matadd(ha,hb); /*十字链表相加*/
printf("A+B:\n"); /*输出相加后的结果*/
print(hc);printf("\n");
P94 数据类型描述如下：
#define elemtype char
struct node1
int atom;
struct node1 *link;
union
struct node1 *slink;
elemtype data;
ds;
P95 数据类型描述如下：
struct node2
elemtype data;
struct node2 *link1,*link2;
P96 求广义表的深度depth(LS)
int depth(struct node1 *LS)
int max=0,dep;
while(LS!=NULL)
if(LS->atom==0) //有子表
dep=depth(LS->ds.slink);
if(dep>max) max=dep;
LS=LS->link;
return max+1;
P96 广义表的建立creat(LS)
void creat(struct node1 *LS)
char ch;
scanf("%c",&ch);
if(ch=='#')
LS=NULL;
else if(ch=='(')
LS=(struct node*)malloc(sizeof(struct node));
LS->atom=0;
creat(LS->ds.slink);
else
LS=(struct node*)malloc(sizeof(struct node));
LS->atom=1;
LS->ds.data=ch;
scanf("%c",&ch);
if(LS==NULL);
else if(ch==',')
creat(LS->link);
else if((ch==')')||(ch==';'))
LS->link=NULL;
P97 输出广义表print(LS)
void print(struct node1 *LS)
if(LS->atom==0)
printf("(");
if(LS->ds.slink==NULL)
printf("#");
else
print(LS->ds.slink);
else
printf("%c ",LS->ds.data);
if(LS->atom==0)
printf(")");
if(LS->link!=NULL)
printf(";");
print(LS->link);
P98 该算法的时间复杂度为O(n)。整个完整程序如下：
#include<stdio.h>
#define elemtype char
struct node1
int atom;
struct node1 *link;
union
struct node1 *slink;
elemtype data;
ds;
;
void creat(struct node1 LS) /*建立广义表的单链表*/
char ch;
scanf("%c",&ch);
if(ch=='#')
LS=NULL;
else if(ch=='(')
LS=(struct node1*)malloc(sizeof(struct node1));
LS->atom=0;
creat(LS->ds.slink);
else
LS=(struct node1*)malloc(sizeof(struct node1));
LS->atom=1;
LS->ds.data=ch;
scanf("%c",&ch);
if(LS==NULL);
else if(ch==',')
creat(LS->link);
else if((ch==')')||(ch==';'))
LS->link=NULL;
void print(struct node1 LS) /*输出广义单链表*/
if(LS->atom==0)
printf("(");
if(LS->ds.slink==NULL)
printf("#");
else
print(LS->ds.slink);
else
printf("%c",LS->ds.data);
if(LS->atom==0)
printf(")");
if(LS->link!=NULL)
printf(";");
print(LS->link);
int depth(struct node1 LS) /*求广义表的深度*/
int max=0;
while(LS!=NULL)
if(LS->atom==0)
int dep=depth(LS->ds.slink);
if(dep>max) max=dep;
LS=LS->link;
return max+1;
main()
int dep;
struct node1 *p=NULL;
creat(p); /*建立广义表的单链表*/
print(p); /*输出广义单链表*/
dep=depth(p); /*求广义表的深度*/
printf("%d\n",dep);
第六章 树
P109 二叉链表的结点类型定义如下：
typedef struct btnode
anytype data;
struct btnode *Lch,*Rch;
tnodetype;
P109 三叉链表的结点类型定义如下：
typedef struct btnode3
anytype data;
struct btnode *Lch,*Rch，*Parent ;
tnodetype3;
P112 C语言的先序遍历算法：
void preorder (tnodetype *t)
/*先序遍历二叉树算法，t为指向根结点的指针*/
if (t!=NULL)
printf("%d ",t->data);
preorder(t->lch);
preorder(t->rch);
P113 C语言的中序遍历算法：
void inorder(tnodetype *t)
/*中序遍历二叉树算法，t为指向根结点的指针*/
if(t!=NULL)
inorder(t->lch);
printf("%d ",t->data);
inorder(t->rch);
P113 C语言的后序遍历算法：
void postorder(tnodetype *t)
/*后序遍历二叉树算法，t为指向根结点的指针*/
if(t!=NULL)
postorder(t->lch);
postorder(t->rch);
printf("%d ",t->data);
P114 如果引入队列作为辅助存储工具，按层次遍历二叉树的算法可描述如下：
void levelorder(tnodetype *t)
/*按层次遍历二叉树算法，t为指向根结点的指针*/
tnodetype q[20]; /*辅助队列*/
front=0;
rear=0; /*置空队列*/
if (t!=NULL)
rear++;
q[rear]=t; /*根结点入队*/
while (front!=rear)
front++;
t=q [front];
printf ("%c\n",t->data);
if (t->lch!=NULL) /*t的左孩子不空，则入队*/
rear++;
q [rear]=t->lch;
if (t->rch!=NULL) /*t的右孩子不空，则入队*/
rear++;
q [rear]=t->rch;
P115 以中序遍历的方法统计二叉树中的结点数和叶子结点数，算法描述为：
void inordercount (tnodetype *t)
/*中序遍历二叉树，统计树中的结点数和叶子结点数*/
if (t!=NULL)
inordercount (t->lch); /*中序遍历左子树*/
printf ("%c\n",t->data); /*访问根结点*/
countnode++; /*结点计数*/
if ((t->lch==NULL)&&(t->rch==NULL))
countleaf++; /*叶子结点计数*/
inordercount (t->rch); /*中序遍历右子树*/
P115 可按如下方法计算一棵二叉树的深度：
void preorderdeep (tnodetype *t,int j)
/*先序遍历二叉树，并计算二叉树的深度*/
if (t!=NULL)
printf ("%c\n",t->data); /*访问根结点*/
j++;
if (k<j) k=j;
preorderdeep (t->lch,j); /*先序遍历左子树*/
preorderdeep (t->rch,j); /*先序遍历右子树*/
P117 线索二叉树的结点类型定义如下：
struct nodexs
anytype data;
struct nodexs *lch, *rch;
int ltag,rtag; /*左、右标志域*/
P117 中序次序线索化算法
void inorderxs (struct nodexs *t)
/*中序遍历t所指向的二叉树，并为结点建立线索*/
if (t!=NULL)
inorderxs (t->lch);
printf ("%c\n",t->data);
if (t->lch!=NULL)
t->ltag=0;
else t->ltag=1;
t->lch=pr;
/*建立t所指向结点的左线索，令其指向前驱结点pr*/
if (pr!=NULL)
if (pr->rch!=NULL)
pr->rtag=0;
else pr->rtag=1;
pr->rch=p;
/*建立pr所指向结点的右线索，令其指向后继结点p*/
pr=p;
inorderxs (t->rch);
P118 在中根线索树上检索某结点的前驱结点的算法描述如下：
struct nodexs * inpre (struct nodexs *q)
/*在中根线索树上检索q所指向的结点的前驱结点*/
if (q->ltag==1)
p=q->lch;
else r=q->lch;
while (r->rtag!=1)
r=r->rch;
p=r;
return (p);
P119 在中根线索树上检索某结点的后继结点的算法描述如下：
struct nodexs * insucc (struct nodexs *q)
/*在中根线索树上检索q所指向的结点的后继结点*/
if (q->rtag==1)
p=q->rch;
else r=q->rch;
while (r->ltag!=1)
r=r->lch;
p=r;
return (p);
P120 算法程序用C语言描述如下：
void sortBT(BT *t,BT *s) /*将指针s所指的结点插入到以t为根指针的二叉树中*/
if (t==NULL) t=s; /*若t所指为空树，s所指结点为根*/
else if (s->data < t->data)
sortBT(t->lch,s); /*s结点插入到t的左子树上去*/
else
sortBT(t->rch,s); /*s结点插入到t的右子树上去*/
P121 二叉排序树结点删除算法的C语言描述如下：
void delnode(bt,f,p)
/*bt为一棵二叉排序树的根指针，p指向被删除结点，f指向其双亲*/
/*当p=bt时f为NULL*/
fag=0; /*fag=0时需修改f指针信息，fag=1时不需修改*/
if (p->lch==NULL)
s=p->rch; /*被删除结点为叶子或其左子树为空*/
else if (p->rch==NULL)
s=p->lch;
else q=p; /*被删除结点的左、右子树均非空*/
s=p->lch;
while (s->rch!=NULL)
q=s;
s=s->rch;
/*寻找s结点*/
if (q=p)
q->lch=s->lch;
else q->rch=s->lch;
p->data=s->data; /*s所指向的结点代替被删除结点*/
DISPOSE(s);
Fag=1;
if (fag=0) /*需要修改双亲指针*/
if (f=NULL)
bt=s; /*被删除结点为根结点*/
else if (f->lch=p)
f->lch=s;
else f->rch=s;
DISPOSE(p); /*释放被删除结点*/
第七章 图
P134 用邻接矩阵表示法表示图，除了存储用于表示顶点间相邻关系的邻接矩阵外，通常还需要用一个顺序表来存储顶点信息。其形式说明如下：
# define n 6 /*图的顶点数*/
# define e 8 /*图的边(弧)数*/
typedef char vextype; /*顶点的数据类型*/
typedef float adjtype; /*权值类型*/
typedef struct
vextype vexs[n];
adjtype arcs[n][n];
graph;
P135 建立一个无向网络的算法。
CREATGRAPH(ga) /*建立无向网络*/
Graph * ga;
int i,j,k;
float w;
for(i＝0;i<n;i++ )
ga ->vexs[i]＝getchar(); /*读入顶点信息，建立顶点表*/
for(i＝0;i<n;i++ )
for(j＝0;j<n;j++)
ga ->arcs[i][j]＝0; /*邻接矩阵初始化*/
for(k＝0;k<e;k++) /*读入e条边*/
(scanf("％d％d％f",&I,&j,&w); /*读入边(vi,vj)上的权w */
ga ->arcs[i][j]＝w;
ga - >arcs[j][i]＝w;
/*CREATGRAPH*/
P136 邻接表的形式说明及其建立算法：
typedef struct node
int adjvex; /*邻接点域*/
struct node * next; /*链域*/
edgenode; /*边表结点*/
typedef struct
vextype vertex; /*顶点信息*/
edgenode link; /*边表头指针*/
vexnode; /*顶点表结点*/
vexnode ga[n];
CREATADJLIST(ga) /*建立无向图的邻接表*/
Vexnode ga[ ];
int i,j,k;
edgenode * s;
for(i=o;i<n;i++＝ /*读入顶点信息*/
(ga[i].vertex＝getchar();
ga[i].1ink＝NULL; /*边表头指针初始化*/
for(k＝0;k<e;k++＝ /*建立边表*/
scanf("％d％d",&i,&j); /*读入边(vi , vj)的顶点对序号*/
s＝malloc(sizeof(edgenode)); /*生成邻接点序号为j的表结点*s */
s-> adjvex＝j;
s- - >next：＝ga[i].Link;
ga[i].1ink＝s; /*将*s插入顶点vi的边表头部*/
s＝malloc(size0f(edgende)); /*生成邻接点序号为i的边表结点*s */
s ->adjvex＝i;
s ->next＝ga[j].1ink;
ga[j].1ink＝s; /*将*s插入顶点vj的边表头部*/
/* CREATADJLIST */
P139 分别以邻接矩阵和邻接表作为图的存储结构给出具体算法，算法中g、g1和visited为全程量，visited的各分量初始值均为FALSE。
int visited[n] /*定义布尔向量visitd为全程量*/
Graph g; /*图g为全程量*/
DFS(i) /*从Vi+1出发深度优先搜索图g，g用邻接矩阵表示*/
int i;
int j;
printf("node：％c＼n" , g.vexs[i]); /*访问出发点vi+1 */
Visited[i]＝TRUE; /*标记vi+l已访问过*/
for (j＝0;j<n;j++) /*依次搜索vi+1的邻接点*/
if((g.arcs[i][j]＝＝1) ＆＆(! visited[j]))
DFS(j); /*若Vi+l的邻接点vj+l未曾访问过，则从vj+l出发进行深度优先搜索*/
/*DFS*/
vexnode gl[n] /*邻接表全程量*/
DFSL(i) /*从vi+l出发深度优先搜索图g1，g1用邻接表表示*/
int i;
int j;
edgenode * p;
printf("node：％C\n" ,g1[i].vertex);
vistited[i]＝TRUE;
p＝g1[i].1ink; /*取vi+1的边表头指针*/
while(p !＝NULL) /*依次搜索vi+l的邻接点*/
if(! Vistited[p ->adjvex])
DFSL(p - >adjvex); /*从vi+1的未曾访问过的邻接点出发进行深度优先搜索*/
p＝p - >next; /*找vi+l的下一个邻接点*/
/* DFSL */
P142 以邻接矩阵和邻接表作为图的存储结构，分别给出宽度优先搜索算法。
BFS(k) /＊从vk+l出发宽度优先搜索图g，g用邻接矩阵表示，visited为访问标志向量*/
int k;
int i,j;
SETNULL(Q); /*置空队Q */
printf("％c＼n"，g.vexs[k]); /*访问出发点vk+l*x/
visited[k]＝TRUE; /*标记vk+l已访问过*/
ENQUEUE(Q，K); /*已访问过的顶点(序号)入队列*/
While(!EMPTY(Q)) /*队非空时执行*/
i＝DEQUEUE(Q); /*队头元素序号出队列*/
for(j＝0;j<n;j++)
if((g.arcs[i][j]＝＝1)＆＆(! visited[j]))
printf("％c＼n" , g.vexs[j]); /*访问vi+l的未曾访问的邻接点vj+l */
visited[j]＝TRUE;
ENQUEUE(Q,j); /*访问过的顶点入队*/
/* BFS */
BFSL(k) /*从vk+l出发宽度优先搜索图g1，g1用邻接表表示*/
int k
int i;
edgenode * p;
SETNULL(Q);
printf("％c＼n" , g1[k].vertex);
visited[k]＝TRUE;
ENQUEUE(Q,k);
while(! EMPTY(Q));
i＝DEQUEUE(Q);
p＝g1[i].1ink /*取vi+l的边表头指针*/
while(p !＝NULL) /*依次搜索vi+l的邻接点*/
if( ! visited[p - >adjvex]) /*访问vi+l的未访问的邻接点*/
printf"％c＼n" , g1[p - >adjvex].vertex;
visited[p - >adjvex]＝TRUE;
ENQUEUE(Q,p - >adjvex); /*访问过的顶点入队*/
p＝p - >next; /*找vi+l的下一个邻接点*/
/*BFSL*/
P148 在对算法Prim求精之前，先确定有关的存储结构如下：
typdef struct
Int fromvex，endvex; /*边的起点和终点*/
float length; /*边的权值*/
edge;
float dist[n][n]; /*连通网络的带权邻接矩阵*/
edgeT[n-1]; /*生成树*/
P149 抽象语句(1)可求精为：
for(j=1;j<n;j++) /*对n-1个蓝点构造候选紫边集*/
T[j-1].fromvex＝1; /*紫边的起点为红点*/
T[j-1].endvex＝j+1; /*紫边的终点为蓝点*/
T[j-1].1ength＝dist[0][j]; /*紫边长度*/
P149 抽象语句(3)所求的第k条最短紫边可求精为：
min＝max; /*znax大于任何边上的权值*/
for (j＝k;j<n-1;j++) /*扫描当前候选紫边集T[k]到T[n-2]，找最短紫边*/
if(T[j].1ength<min)
min＝T[j].1ength;m＝j; /*记录当前最短紫边的位置*/
P149 抽象语句(4)的求精：
e＝T[m];T[m]＝T[k];T[k]＝e， /* T[k]和T[m]交换*/
v＝T[kl.Endvex]; /* v是刚被涂红色的顶点*/
P149 抽象语句(5)可求精为：
for(j＝k+1;j<n-1;j++) /*调整候选紫边集T[k+1]到T[n-2]*/
d＝dist[v-1][T[j].endvex-1]; /*新紫边的长度*/
if(d<T[j].1ength) /*新紫边的长度小于原最短紫边*/
T[j].1ength＝d;
T[j].fromvex＝v; /*新紫边取代原最短紫边*/
P150 完整的算法：
PRIM() /*从第一个顶点出发构造连通网络dist的最小生成树，结果放在T中*/
int j , k , m , v , min , max＝l0000;
float d;
edge e;
for(j=1;j<n;j++) /*构造初始候选紫边集*/
T[j-1].formvex＝1; /*顶点1是第一个加入树中的红点*/
T[j-1].endvex＝j+1;
T[j-1].length＝dist[o][j];
for(k＝0;k<n-1;k++) /*求第k条边*/
min＝max;
for(j＝k;j<n-1;j++) /*在候选紫边集中找最短紫边*/
if(T[j].1ength<min)
min＝T[j].1ength;
m＝j;
/*T[m]是当前最短紫边*/
e＝T[m];T[m]＝T[k];T[k]＝e; /*T[k]和T[m]交换后，T[k]是第k条红色树边*/
v＝T[k].endvex ; /* v是新红点*/
for(j＝k+1;j<n-1;j++) /*调整候选紫边集*/
d＝dist[v-1][T[j].endvex-1];
if(d<T[j].1ength);
T[j].1ength＝d;
T[j].fromvex＝v;
/* PRIM */
P151 Kruskl算法的粗略描述：
T＝(V,φ);
While(T中所含边数<n-1)
从E中选取当前最短边(u,v);
从E中删去边(u,v);
if((u,v)并入T之后不产生回路，将边(u,v)并入T中;
P153 迪杰斯特拉算法实现。算法描述如下：
#define max 32767 /*max代表一个很大的数*/
void dijkstra (float cost[][n],int v)
/*求源点v到其余顶点的最短路径及其长度*/
v1=v-1;
for (i=0;i<n;i++)
dist[i]=cost[v1][i]; /*初始化dist*/
if (dist[i]<max)
pre[i]=v;
else pre[i]=0;
pre[v1]=0;
for (i=0;i<n;i++)
s[i]=0; /*s数组初始化为空*/
s[v1]=1; /*将源点v归入s集合*/
for (i=0;i<n;i++)
min=max;
for (j=0;j<n;j++)
if (!s[j] && (dist[j]<min))
min=dist[j];
k=j;
/*选择dist值最小的顶点k+1*/
s[k]=1; /*将顶点k+1归入s集合中*/
for (j=0;j<n;j++)
if (!s[j]&&(dist[j]>dist[k]+cost[k][j]))
dist[j]=dist[k]+cost[k][j]; /*修改 V-S集合中各顶点的dist值*/
pre[j]=k+1; /*k+1顶点是j+1顶点的前驱*/
/*所有顶点均已加入到S集合中*/
for (j=0;j<n;j++) /*打印结果*/
printf("%f\n%d",dist[j],j+1;);
p=pre[j];
while (p!=0)
printf("%d",p);
p=pre[p-1];
P155 弗洛伊德算法可以描述为：
A(0)[i][j]=cost[i][j]; //cost为图的邻接矩阵
A(k)[i][j]=minA(k-1) [i][j],A(k-1) [i][k]+A(k-1) [k][j]
其中 k=1,2,…,n
P155 弗洛伊德算法实现。算法描述如下：
int path[n][n]; /*路径矩阵*/
void floyd (float A[][n],cost[][n])
for (i=0;i<n;i++) /*设置A和path的初值*/
for (j=0;j<n;j++)
if (cost[i][j]<max)
path[i][j]=j;
else path[i][j]=0;
A[i][j]=cost[i][j];
for (k=0;k<n;k++)
/*做n次迭代，每次均试图将顶点k扩充到当前求得的从i到j的最短路径上*/
for (i=0;i<n;i++)
for (j=0;j<n;j++)
if (A[i][j]>(A[i][k]+A[k] 参考技术A 考考自己吧
人不能总能依靠别人. 参考技术B 这些代码都可以在知道里面直纯属体力劳动，重复的无意义工作我还是不要做了...
接搜到，无需再悬赏。 参考技术C 回答完你这些问题我要几个小时，你就给150分，太少了吧 参考技术D 这些代码都可以在知道里面直接搜到，无需再悬赏。
经典实验--飞机大战小游戏
·一、需求设计
1.为检测C语言的学习成果,根据所学的C语言知识,设计程序:飞机大战小游戏;
2.自行定义变量,函数或结构体,编写源代码并进行编译运行测试;
3.根据编写的代码,自行攥写实验报告;
·二、系统设计
1 实验题目：
飞机大战小游戏
2 游戏描述
飞机大战是一款惊险刺激的射击游戏,通过控制飞机的上下左右移动,发射子弹,击退敌机并赢得分数,玩游戏既可以锻炼人的反应能力,也可以起到放松身心的作用.
进行C语言面向对象程序设计课程设计主要是在学习C语言这门面向对象语言的基础上，并通过实践加深对 C语言面向对象程序设计语言特点的认识与理解。同时，可以提高运用C编程语言解决实际问题的能力；锻炼实际的编程能力；还能提高调查研究、查阅技术文 献、资料以及编写软件设计文档的能力。
3 功能要求
【1】 实现游戏难度的选择,飞机模型以及界面的外观设计等的功能。
【2】 实现方向操移动的操作和敌机随机生成功能。
【3】 分数计算功能。
【4】 游戏的开始,暂停,结束以及分数显示的功能。
三、概要设计
1 简要设计及所涉及的知识
运用二维数组的加减和循环来设计游戏.通过下,xy的加减实现位置的移动;然后用一系列函数,实现各功能;
2 功能描述
(1) 难度选择: 1为困难,2为一般,3为简单,Enter开始游戏;
(2) 操作:按1235控制飞机左下右上移动,空格发射子弹,按8暂停,按0停止游戏并输出分数;;
(3) 游戏的测评方式为计分制,每击中一架敌机分数加1,无分数限制;
·四 详细设计
1定义全局变量
(1) long long int speed = 0;//控制敌机的速度
(2) int position_x, position_y;//飞机的所在位置
(3) int high, width;//地图的大小
(4) int bullet_x, bullet_y;//子弹的位置
(5) int enemy_x, enemy_y;//敌人的位置
(6) int map[MAX][MAX];
(7) /*地图符号说明:0表示空白，1表示战机*的区域，2表示敌人战机的位置。
(8) 3表示上下围墙，4表示左右围墙,5表示子弹的位置*/
(9) int score,time,degree,choice;//分数,时间,难度,重新开始
2 定义功能函数
(1) void starup();//初始化所有的信息
(2) void startMap();//地图内容初始化
(3) void HideCursor();//隐藏光标 ,不会出现光标的闪烁
(4)void gotoxy(int x, int y);//清理一部分屏幕
(5)void updateWithoutInput();//与输入无关的更新
(6)void updateWithInput();//与输入有关的更新
(7)void show();//展示的内容
(8)int menu();//菜单初始化
(9)void showend();//结束菜单
(10)void stop();//暂停游戏
3 制作流程
飞机大战的主要实现的功能是让飞机移动,飞机的移动可以通过二维数组实现,首先对飞机的坐标设置初值为屏幕的中间位置,通过横纵坐标的加减实现左右移动,每移动一个单位清屏一次;
第二个过程是随机产生敌机,我们可以定义一个随机数组[]0][y],y是随机产生的,通过x++实现敌机的前进;在定义一个void函数,当输入空格键时,在当前飞机所在的位置产生一个子弹[x][y],之后x递减,从而实现子弹的前进;
第三,当敌机和子弹的坐标相同时,子弹击中敌机,此时将此刻的敌机和子弹同时清除,分数加1,并随机生成一架敌机,;或当飞机飞出规定区域后,清除该敌机并随机生成;
实现这三个功能后即可完成基本的操作;之后需要考虑的是敌机速度的调控,在每次敌机x++之前添加一次循环.飞机前进的速度与循环的次数成正比;这样就实现了速度的快慢;
剩下的问题就是完善其他简单的内容,如难度选择,分数的输出,界面设置及游戏的暂停和终止等;
五、系统实现与测试
5.1开始游戏测试
图5-1-1 游戏开始及难度选择界面
5.2难度选择
图5-2-1 难度1 困难模式
图5-2-2 难度2 一般模式
图5-2-3 难度3 简单模式
难度选择后,按Enter开始游戏
5.3游戏开始
图5-3-1 游戏开始界面
图5-3-2 游戏正在进行的截图
按1 2 3 5 进行←↓→↑移动,按 空格 发射子弹射击
5.4游戏暂停
图5-4-1 暂停界面
按8 暂停游戏 ,再次输入8 继续游戏
5.5游戏结束
图5-5-1 游戏结束界面
按0结束游戏,并会输出游戏得分,按任意键退出游戏;
5.6 综合说明
游戏开始后,先进行难度选择.1 2 3依次为困难,一般和简单,玩家可根据自身喜好进行难度选择;难度选择好后按Enter开始游戏,进入游戏后,按1 2 3 5 进行←↓→↑移动,按 空格 发射子弹射击,对准敌机进行射击,
六、结论与心得
通过这段时间学习的C语言课程设计,学会了很多同时也收获了很多,学会了如何根据根据问题去思考解决的思路,和编写代码;虽然这个过程有点枯燥乏味,有时半天都没思路,想不出该怎么写怎么算,但是等到真的想到思路的时候,会发现自己之前的付出是值得的,那种喜悦感非常棒;
而且还收获了好多知识,不光有上学期学到的C语言知识,还有还有好多编程方面的技巧和经验,这些东西对以后的学习和工作会有很大的帮助;最后通过本次大作业可有让自己对所学过的知识加以整理和检验,既可以整理C语言和编程知识,还可以检验自己的一些缺点和不足,为以后的学习和工作打下基础;
七、源代码
1、int main();//主函数
#include<stdio.h> #include<string.h> #include<conio.h>//清屏所需头文件 #include<windows.h>//清屏所需头文件 #include<stdlib.h>
//*********定义全局变量*********
long long int speed = 0;//控制敌机的速度
int position_x, position_y;//飞机的所在位置
int high, width;//地图的大小
int bullet_x, bullet_y;//子弹的位置
int enemy_x, enemy_y;//敌人的位置
int map[MAX][MAX];
/*地图符号说明:0表示空白，1表示战机*的区域，2表示敌人战机的位置。
3表示上下围墙，4表示左右围墙,5表示子弹的位置*/
int score,time,degree,choice;//分数,时间,难度,重新开始
//********定义功能函数*********
void starup();//初始化所有的信息
void startMap();//地图内容初始化
void HideCursor();//隐藏光标 ,不会出现光标的闪烁
void gotoxy(int x, int y);//清理一部分屏幕
void updateWithoutInput();//与输入无关的更新
void updateWithInput();//与输入有关的更新
void show();//展示的内容
int menu();//菜单初始化
void showend();//结束菜单
void stop();//暂停游戏
#define MAX 100 int main() { int a; if(menu()) starup(); while (1) { HideCursor(); startMap(); show(); updateWithoutInput(); updateWithInput(); } return 0; }
2、void starup();//初始化所有的信息
void starup()//初始化所有的信息 { high = 20; width = 30; position_x = high / 2; position_y = width / 2; bullet_x = 0; bullet_y = position_y; enemy_x = 2; enemy_y = position_y - 1; score = 0; }
3、void startMap();//地图内容初始化
void startMap()//地图内容初始化 { int i, j; for (i = 1; i <= high -1; i++) { map[i][1] = 4; for (j = 2; j <= width - 1; j++) map[i][j] = 0; map[i][width] = 4; } //下方围墙的初始化 i = high; for (j = 1; j <= width; j++) map[i][j] = 3; map[bullet_x][bullet_y] = 5; /*这里是战机大小的初始化开始*/ map[position_x - 1][position_y] = 1; i = position_x; for (j = position_y - 2; j <= position_y + 2; j++) map[i][j] = 1; map[position_x + 1][position_y - 1] = 1; map[position_x + 1][position_y + 1] = 1; /*** 初始化结束 **/ /* 敌人战机的初始化 */ map[enemy_x][enemy_y] = 2; map[enemy_x - 1][enemy_y - 1] = 2; map[enemy_x - 1][enemy_y + 1] = 2; /* 敌人战机初始化结束*/ }
4、void HideCursor();//隐藏光标 ,不会出现光标的闪烁
void HideCursor()//隐藏光标 ,不会出现光标的闪烁 { CONSOLE_CURSOR_INFO cursor_info = { 1, 0 }; SetConsoleCursorInfo(GetStdHandle(STD_OUTPUT_HANDLE), &cursor_info); }
5、void gotoxy(int x, int y);//清理一部分屏幕
void gotoxy(int x, int y)//清理一部分屏幕 { HANDLE handle = GetStdHandle(STD_OUTPUT_HANDLE); COORD pos; pos.X = x; pos.Y = y; SetConsoleCursorPosition(handle, pos); }
6、void updateWithoutInput();//与输入无关的更新
void updateWithoutInput()//与输入无关的更新
{
if (bullet_x > 0)//实现子弹的前进
bullet_x--;
if (((bullet_x == enemy_x) && (bullet_y == enemy_y))||((bullet_x == enemy_x-1) && (bullet_y == enemy_y-1))||((bullet_x == enemy_x+1) && (bullet_y == enemy_y+1)))//当敌人的飞机被击中时,同时清子弹和飞机
{
score++;
enemy_x = 0;
enemy_y = rand() % width;//随机产生新敌机
bullet_x = 0;
}
else if (enemy_x > high)//当飞机超出区域
{
enemy_x = 0;
enemy_y = rand() % width;//随机产生新敌机
}
if (speed == 1)
for (int i = 1; i <=10*(15*degree-10); i++)//用来控制敌机的速度 ,通过循环的次数实现
{
for (int j = 1; j <=10000; j++)
{
speed = 1;
}
}
speed = 0;
if (speed == 0)
{
enemy_x++;
speed = 1;
}
}
7、void updateWithInput();//与输入有关的更新
void updateWithInput()//与输入有关的更新 { char input; if (kbhit()) { input = getch(); if (input == \'1\') position_y--; if (input == \'2\') position_x++; if (input == \'3\') position_y++; if (input == \'5\') position_x--; if (input ==\'8\') stop(); if( input==\'0\') showend(); if (input == \' \') { bullet_x = position_x - 1; bullet_y = position_y; } } }
8、void show();//展示的内容
void show()//展示的内容 { gotoxy(0, 0); int i, j; for (i = 1; i <= high; i++) { for (j = 1; j <= width; j++) { if (map[i][j] == 0) printf(" ");// 活动空间 if (map[i][j] == 1) printf("*");//控制的飞机 if (map[i][j] == 2) printf("#");//敌方飞机 if (map[i][j] == 3) printf("~");//下边界 if (map[i][j] == 4) printf("|");//左右边界 if (map[i][j] == 5) printf(":");//子弹 } printf("\\n"); } printf("\\n你的得分:%d\\n\\n", score); printf("操作说明: 1235分别操作 左下右上四个的移动\\n"); printf("**空格是发出子弹**\\n"); }
9、int menu();//菜单初始化
int menu() { printf("******************************\\n") ; printf("* *\\n") ; printf("* 欢迎来到飞机大战 *\\n") ; printf("* *\\n") ; printf("* Hard == 1 *\\n") ; printf("* Normal == 2 *\\n") ; printf("* Easy == 3 *\\n") ; printf("* *\\n") ; printf("* Enter开始游戏 *\\n") ; printf("* *\\n") ; printf("* *\\n") ; printf("******************************\\n") ; scanf("%d",°ree); system("cls"); return degree; }
10、void showend();//结束菜单
void showend() { int s; system("cls"); printf("******************************\\n") ; printf("* *\\n") ; printf("* Gime Over ! *\\n") ; printf("* *\\n") ; printf("* Your scores are %d! *\\n",score); printf("* *\\n") ; printf("* Very Good ! *\\n") ; printf("* *\\n") ; printf("* 按任意键退出 *\\n") ; printf("* *\\n") ; printf("* *\\n") ; printf("* *\\n") ; printf("******************************\\n") ; exit(0); }
11、void stop();//暂停游戏
void stop() { int s; system("cls"); printf("******************************\\n") ; printf("* *\\n") ; printf("* Gime Pause ! *\\n") ; printf("* *\\n") ; printf("* Your scores are %d! *\\n",score); printf("* *\\n") ; printf("* 按8继续游戏 *\\n") ; printf("* *\\n") ; printf("* 按任意键退出 *\\n") ; printf("* *\\n") ; printf("* *\\n") ; printf("* *\\n") ; printf("******************************\\n") ; scanf("%d",&s); if(s!=8) exit(0); }
以上是关于c语言数据结构（考题，测试你的能力）－－编写源代码的主要内容，如果未能解决你的问题，请参考以下文章