文档文库

手机版

投诉建议

首页 > 经典数据结构上机题—答案

经典数据结构上机题—答案

发布时间：2020-05-30 10:17:47 来源：文档文库

小中大

字号：

手机查看

数据结构上机实验题目

实验一线性表的顺序存储结构

实验学时 2学时

背景知识:顺序表的插入、删除及应用。

目的要求：

1．掌握顺序存储结构的特点。

2．掌握顺序存储结构的常见算法。

实验内容

1．输入一组整型元素序列，建立顺序表。

2．实现该顺序表的遍历。

3．在该顺序表中进行顺序查找某一元素,查找成功返回1,否则返回0。

4．判断该顺序表中元素是否对称,对称返回1,否则返回0。

5．实现把该表中所有奇数排在偶数之前,即表的前面为奇数,后面为偶数。

6．输入整型元素序列利用有序表插入算法建立一个有序表。

7．利用算法6建立两个非递减有序表并把它们合并成一个非递减有序表。

8. 利用该顺序结构实现循环队列的入队、出队操作。

8．编写一个主函数,调试上述算法。

#include

#define OVERFLOW 0

#define MAXSIZE 100

typedef int ElemType;

typedef struct list

{ElemType elem[MAXSIZE];

int length;

}Sqlist;

void Creatlist(Sqlist &L)

{int i;

printf("请输入顺序表的长度："); //输入一组整型元素序列，建立一个顺序表。

scanf("%d",&L.length);

for(i=0;i

scanf("%d",&L.elem[i]);

}

void printlist(Sqlist &L) //以输出的形式实现对该顺序表的遍历

{int i;

for(i=0;i

printf("%d ",L.elem[i]);

printf("\n");

}

void Searchlist(Sqlist &L,int x) //在顺序表中进行顺序查找某一元素x，查找成功则返回其存储位置i，否则返回错误信息

{int i,k=-1;

for(i=0;i

if(L.elem[i]==x){

k=i+1;printf("%d ",k);}

if(k==-1)

printf("error!");

printf("\n");

}

void Inseri(Sqlist &L,int i,int x) //在顺序表的第i个位置上插入一个元素x

{int j;

for(j=L.length;j>=i;j--)

L.elem[j]=L.elem[j-1];

L.elem[j]=x;

L.length++;

}

void Delete(Sqlist &L,int i) //删除顺序表中第i个元素

{int j;

for(j=i;j

L.elem[j-1]=L.elem[j];

L.length--;

}

void Insert(Sqlist &L,int x) //输入一个元素x，把它插入到有序表中，使顺序表依然有序。

{int i,j;

if(L.length==MAXSIZE) exit(OVERFLOW); //表满，不能插入

for(i=1;i<=L.length&&L.elem[i-1]<=x;i++);

for(j=L.length;j>=i;j--)

L.elem[j]=L.elem[j-1];

L.elem[i-1]=x;

L.length++;

}

void Creatlist_sorted(Sqlist &L) //利用有序表插入算法建立一个有序表

{int i,num;

ElemType x;

L.length=0;

printf("请输入顺序表的长度：");

scanf("%d",&num);

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

{

scanf("%d",&x);

Insert(L,x);

}

void Merger(Sqlist &p,Sqlist &r,Sqlist &c) //建立两个非递减有序表，并把它们合并成一个非递减有序表

{

ElemType *a,*b,i=0,j=0,k=0;

a=&p.elem[0];

b=&r.elem[0];

c.length=p.length+r.length;

while(i

{if(*a>=*b)

{c.elem[k]=*b;b++;k++;j++;}

else {c.elem[k]=*a;a++;k++;i++;}

}

if(j==r.length)

for(;k

{c.elem[k]=*a;a++; }

else if(i==p.length)

for(;k

{c.elem[k]=*b;b++;}

}

void main()

{Sqlist L,M,N;

int x,i,n;

printf("1.建立一个顺序表.\n");

printf("2.以输出的形式对该顺序表遍历.\n");

printf("3.在顺序表中进行顺序查找某一元素x.\n");

printf("4.在顺序表的第i个位置上插入一个元素x.\n");

printf("5.删除顺序表中第i个元素.\n");

printf("6.利用有序表插入算法建立一个有序表.\n");

printf("7.建立两个非递减有序表，并把它们合并成一个非递减有序表.\n");

printf("8.输入一个元素x，把它插入到有序表中，使顺序表依然有序.\n");

while(1){

printf("请选择：");

scanf("%d",&n);

switch(n)

{case 1:Creatlist(L);break;

case 2:printlist(L);break;

case 3:printf("请输入要查找的元素x:");

scanf("%d",&x);

Searchlist(L,x);break;

case 4:printf("请输入要插入的位置i:");

scanf("%d",&i);

if(i<1||i>L.length+1){

printf("error!\n");break;}

printf("请输入要插入的值x:");

scanf("%d",&x);

Inseri(L,i,x);

printlist(L);break;

case 5:printf("请输入要删去的元素的位置i:");

scanf("%d",&i);

if(i<1||i>L.length){

printf("error!\n");break;}

Delete(L,i);

printlist(L);break;

case 6:Creatlist_sorted(L);

printlist(L);break;

case 7:Creatlist_sorted(L);

Creatlist_sorted(M);

Merger(L,M,N);

printlist(N);break;

case 8:Creatlist_sorted(L);

printf("请输入要插入的元素x:");

scanf("%d",&x);

Insert(L,x);

printlist(L);break;

}

实验二链式存储结构（一）----单向链表的有关操作

实验学时 3学时

背景知识：单向链表的插入、删除及应用。

目的要求

1．掌握单向链表的存储特点及其实现。

2．掌握单向链表的插入、删除算法及其应用算法的程序实现。

实验内容

1．随机产生或键盘输入一组元素，建立一个带头结点的单向链表（无序）。

2．遍历单向链表。

3．把单向链表中元素逆置（不允许申请新的结点空间）。

4．在单向链表中删除所有的偶数元素结点。

5．编写在非递减有序链表中插入一个元素使链表元素仍有序的函数，并利用该函数建立一个非递减有序单向链表。

6．利用算法5建立两个非递减有序单向链表，然后合并成一个非递增链表。

7．利用算法5建立两个非递减有序单向链表，然后合并成一个非递减链表。

8．利用算法1建立的链表，实现将其分解成两个链表，其中一个全部为奇数，另一个全部为偶数（尽量利用已知的存储空间）。

* 9．采用单向链表实现一元多项式的存储并实现两个多项式相加并输出结果。

10．在主函数中设计一个简单的菜单，分别调试上述算法。

*11．综合训练：利用链表实现一个班级学生信息管理（数据录入、插入、删除、排序、查找等，并能够实现将数据存储到文件中）

/*单向链表的有关操作示例*/

/*类型定义及头文件部分,文件名为sllink.h*/

#include

typedef int ElemType;//元素实际类型

typedef struct LNode{

ElemType data;

struct LNode *next;

}LNode,*LinkList; //定义结点、指针类型名

//头插法建立无序链表

void CreateList(LinkList &L){

LinkList p;

ElemType e;

L=(LinkList)malloc(sizeof(LNode));

L->next=NULL;

printf("头插法建立链表，以0结束\n");

scanf("%d",&e);

while(e){

p=(LinkList)malloc(sizeof(LNode));

p->data=e;

p->next=L->next;

L->next=p;

scanf("%d",&e);

}

/*非递减有序单向链表L插入元素e序列仍有序*/

void Insert_Sort(LinkList &L,ElemType e){

LinkList p,s;

s=(LinkList)malloc(sizeof(LNode));

s->data=e;

p=L;

while(p->next&&p->next->data<=e)

p=p->next;/*查找插入位置*/

s->next=p->next; /*插入语句*p结点后插入*s结点*/

p->next=s;

}

/*建立递增有序的单向链表*/

void Create_Sort(LinkList &L){

ElemType e;

L=(LinkList)malloc(sizeof(LNode));

L->next=NULL;

printf("建立有序表，输入任意个整型数据以0结束\n");

scanf("%d",&e);

while(e){

Insert_Sort(L,e);

scanf("%d",&e);

}

/*单向链表的遍历*/

void Traverse(LinkList L){

LinkList p;

printf("遍历链表");

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

printf("%5d",p->data);

printf("\n");

}

/*在单向链表删除元素e*/

void Delete(LinkList &L,ElemType e){

LinkList p,q;

p=L;

q=L->next;

while(q&& q->data!=e){//查找元素的删除位置

p=q;

q=q->next;

}

if(!q) printf("\nnot deleted");/*未找到元素e*/

else {p->next=q->next;/*找到删除*/

free(q);}

}

/*单向链表的逆置*/

void exch(LinkList &L){

LinkList p,s;

p=L->next;

L->next=NULL;

while(p){

s=p;

p=p->next;

s->next=L->next;

L->next=s;

}

/*两个非递减有序单向链表合并后仍为非递减序列*/

void MergeIncrease(LinkList La,LinkList Lb,LinkList &Lc){

LinkList p,q,s,rear;

p=La->next;

q=Lb->next;

Lc=rear=La;

free(Lb);

while(p&&q){

if (p->datadata) {s=p;p=p->next; }

else {s=q;q=q->next; }

rear->next=s;/*较小元素插入表尾*/

rear=rear->next;

}

if (p) rear->next=p; else rear->next=q

实验三迷宫问题求解

实验学时 3学时

背景知识：栈的操作。

目的要求

1．掌握栈的存储特点及其实现。

2．掌握栈的出栈和入栈操作。

实验内容：

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

要求：首先实现一个顺序或链表做存储结构的栈类型，然后编写一个求解迷宫的非递归程序。求得的通路以三元组(i, j, d)的形式输出，其中：(i, j)表示迷宫的坐标，d表示走到下一坐标的方向。如对下面的迷宫，输出的一条通路为：（1，1，1），（1，2，2），（2，2，2），（3，2，3），（3，1，2），…...

迷宫约定， x方向为行方向，y方向为列方向，迷宫开始坐标(左上角)为（1,1）。

#include

struct node

{

int sign;//标识,0什么都不在,1在open中,2在closed中

int flag;//标志位 0/1,0可以走,1不可以走

int f,g,h;//判断函数

int x,y;//坐标

int old;//是否old节点,0非,1是

};

struct link

{

node fnode;

link *next;

link *pri;

};

link *open,*closed,*bestnode,*successor,*p,*q,*r,*s;

int maze_flag[7][7]={ {0,1,0,0,0,0,0},

{0,1,0,1,0,1,0},

{0,1,0,0,0,1,0},

{0,1,0,1,0,1,0},

{0,0,0,1,0,0,0},

{1,1,0,1,0,1,0},

{0,0,0,0,0,1,0}};//表示迷宫的数组,0可以走,1不可以走

node maze[7][7];

int judge(node n)//判断函数,判断n节点是否可以走

{

if(n.flag==1)

return(1);

else

return(0);

}

void in_open(node n)//将n节点放入open表

{

p=open;

while(p->next!=open)

{

if(n.f>=p->fnode.f)

{

p->next->pri=(link *)malloc(sizeof(link));

p->next->pri->pri=p;

p=p->next;

p->pri->next=p;

p->pri->pri->next=p->pri;

p=p->pri;

p->fnode.flag=n.flag;

p->fnode.f=n.f;

p->fnode.g=n.g;

p->fnode.h=n.h;

p->fnode.x=n.x;

p->fnode.y=n.y;

p->fnode.old=n.old;

p->fnode.sign=n.sign=1;

}

else

p=p->next;

}

open->pri=(link *)malloc(sizeof(link));

open->pri->pri=p;

open->pri->next=open;

p->next=open->pri;

p=p->next;

p->fnode.flag=n.flag;

p->fnode.f=n.f;

p->fnode.g=n.g;

p->fnode.h=n.h;

p->fnode.x=n.x;

p->fnode.y=n.y;

p->fnode.old=n.old;

p->fnode.sign=n.sign=1;

}

void out_open(node n)//将n节点从open表中移出

{

p=open;

while(p->next!=open)

{

if(n.f=p->fnode.f)

{

link *p1;

p1=p->next;

p->next=p->next->next;

p->next->pri=p;

free(p1);

n.sign=0;

}

else

p=p->next;

}

void in_closed(node n)//将n节点放入closed表

{

while(q->next!=closed)

{

if(n.f>=q->fnode.f)

{

q->next->pri=(link *)malloc(sizeof(link));

q->next->pri->pri=q;

q=q->next;

q->pri->next=p;

q->pri->pri->next=q->pri;

q=q->pri;

q->fnode.flag=n.flag;

q->fnode.f=n.f;

q->fnode.g=n.g;

q->fnode.h=n.h;

q->fnode.x=n.x;

q->fnode.y=n.y;

q->fnode.old=n.old;

q->fnode.sign=n.sign=2;

}

else

q=q->next;

}

closed->pri=(link *)malloc(sizeof(link));

closed->pri->pri=q;

closed->pri->next=closed;

q->next=closed->pri;

q=q->next;

q->fnode.flag=n.flag;

q->fnode.f=n.f;

q->fnode.g=n.g;

q->fnode.h=n.h;

q->fnode.x=n.x;

q->fnode.y=n.y;

q->fnode.old=n.old;

q->fnode.sign=n.sign=2;

}

void out_closed(node n)//将n节点从closed表中移出

{

q=closed;

while(q->next!=closed)

{

if(n.f=q->fnode.f)

{

link *q1;

q1=q->next;

q->next=q->next->next;

q->next->pri=q;

free(q1);

n.sign=0;

}

else

q=q->next;

}

void in_bestnode(node n)//将n节点设为bestnode节点

{

while(r->next!=bestnode)

{

if(n.f>=r->fnode.f)

{

r->next->pri=(link *)malloc(sizeof(link));

r->next->pri->pri=r;

r=r->next;

r->pri->next=r;

r->pri->pri->next=r->pri;

r=r->pri;

r->fnode.flag=n.flag;

r->fnode.f=n.f;

r->fnode.g=n.g;

r->fnode.h=n.h;

r->fnode.x=n.x;

r->fnode.y=n.y;

r->fnode.old=n.old;

}

else

r=r->next;

}

bestnode->pri=(link *)malloc(sizeof(link));

bestnode->pri->pri=r;

bestnode->pri->next=bestnode;

r->next=bestnode->pri;

r=r->next;

r->fnode.flag=n.flag;

r->fnode.f=n.f;

r->fnode.g=n.g;

r->fnode.h=n.h;

r->fnode.x=n.x;

r->fnode.y=n.y;

r->fnode.old=n.old;

}

void out_bestnode(node n)//将n节点的bestnode去掉

{

r=bestnode;

while(r->next!=bestnode)

{

if(n.f=p->fnode.f)

{

link *r1;

r1=r->next;

r->next=r->next->next;

r->next->pri=r;

free(r1);

}

else

r=r->next;

}

void in_successor(node n)//将n节点设置为successor节点

{

s=successor;

while(s->next!=successor)

{

if(n.f>=s->fnode.f)

{

s->next->pri=(link *)malloc(sizeof(link));

s->next->pri->pri=s;

s=p->next;

s->pri->next=s;

s->pri->pri->next=s->pri;

s=s->pri;

s->fnode.flag=n.flag;

s->fnode.f=n.f;

s->fnode.g=n.g;

s->fnode.h=n.h;

s->fnode.x=n.x;

s->fnode.y=n.y;

s->fnode.old=n.old;

}

else

s=s->next;

}

successor->pri=(link *)malloc(sizeof(link));

successor->pri->pri=s;

successor->pri->next=successor;

s->next=successor->pri;

s=s->next;

s->fnode.flag=n.flag;

s->fnode.f=n.f;

s->fnode.g=n.g;

s->fnode.h=n.h;

s->fnode.x=n.x;

s->fnode.y=n.y;

s->fnode.old=n.old;

}

void out_successor(node n)//将n节点的successor去掉

{

s=successor;

while(s->next!=successor)

{

if(n.f=p->fnode.f)

{

link *s1;

s1=s->next;

s->next=s->next->next;

s->next->pri=s;

free(s1);

}

else

s=s->next;

}

void print(link *n)//输出link类型的表n

{

link *forprint;

forprint=n;

printf("the key is ");

while(forprint->next!=n)

printf("(%d,%d)\n",forprint->fnode.x,forprint->fnode.y);

}

int main()

{

//初始化部分

//这部分的功能是将二维的整形数组赋值给node型的二维数组

int i=0,j=0;

for(i=0;i<7;i++)

for(j=0;j<7;j++)

{

maze[i][j].x=i;

maze[i][j].y=j;

maze[i][j].flag=maze_flag[i][j];

if(maze[i][j].flag==0)

{

maze[i][j].h=6-i+6-j;

maze[i][j].sign=maze[i][j].f=maze[i][j].g=maze[i][j].old=0;

}

else

maze[i][j].h=-1;

}

for(i=0;i<7;i++)//输出迷宫示意图

{

for(j=0;j<7;j++)

{

printf("%2d",maze_flag[i][j]);

}

printf("\n");

}

//这部分的功能是将open,closed,bestnode表初始化,都置为空表

p=open=(link *)malloc(sizeof(link));

open->next=open;

open->pri=open;

q=closed=(link *)malloc(sizeof(link));

closed->next=closed;

closed->pri=closed;

r=bestnode=(link *)malloc(sizeof(link));

bestnode->next=bestnode;

bestnode->pri=bestnode;

//将第一个元素即(0,0)节点放入open表,开始算法

in_open(maze[0][0]);

maze[0][0].f=maze[0][0].h;

link *s2;

s2=successor;

if(open->next!=open)//open表为空时则失败退出

{

while(1)

{

in_bestnode(open->fnode);//将open表的第一个元素放入bestnode中

in_closed(maze[open->fnode.x][open->fnode.y]);//将open表的第一个元素放入closed中

maze[open->fnode.x][open->fnode.y].g++;//将open表的第一个元素的g值加一,表示已经走了一步

out_open(maze[open->fnode.x][open->fnode.y]);//将open表的第一个元素删除

if(bestnode->fnode.x==6&&bestnode->fnode.y==6)//若bestnode是目标节点,则成功退出

{

printf("succes!!\nthen print the key:\n");

print(closed);

break;

}

else//若bestnode不是目标节点,则扩展其临近可以走的节点为successor

{

if(i==0||j==0||i==6||j==6)

{

if(i==0&&j==0)//若为(0,0),则判断右边和下边的元素

{

if(judge(maze[i][j+1])==0)

in_successor(maze[i][j+1]);

if(judge(maze[i+1][j])==0)

in_successor(maze[i+1][j]);

}

else if(i==0&&j==6)//若为(0,6),则判断左边和下边的元素

{

if(judge(maze[i-1][j])==0)

in_successor(maze[i-1][j]);

if(judge(maze[i+1][j])==0)

in_successor(maze[i+1][j]);

}

else if(i==6&&j==0)//若为(6,0),则判断左边和上边的元素

{

if(judge(maze[i-1][j])==0)

in_successor(maze[i-1][j]);

if(judge(maze[i][j-1])==0)

in_successor(maze[i][j-1]);

}

else if(i==6&&j==6)//若为(6,6),则判断左边和上边的元素

{

if(judge(maze[i-1][j])==0)

in_successor(maze[i-1][j]);

if(judge(maze[i][j-1])==0)

in_successor(maze[i][j-1]);

}

else if(i==0)//若为第一行的元素(不在角上),则判断左边,下边和右边

{

if(judge(maze[i][j+1])==0)

in_successor(maze[i][j+1]);

if(judge(maze[i][j-1])==0)

in_successor(maze[i][j-1]);

if(judge(maze[i+1][j])==0)

in_successor(maze[i+1][j]);

}

else if(i==6)//若为第七行的元素(不在角上),则判断左边,上边和右边

{

if(judge(maze[i][j+1])==0)

in_successor(maze[i][j+1]);

if(judge(maze[i][j-1])==0)

in_successor(maze[i][j-1]);

if(judge(maze[i-1][j])==0)

in_successor(maze[i-1][j]);

}

else if(j==0)//若为第一列的元素(不在角上),则判断右边,下边和上边

{

if(judge(maze[i+1][j])==0)

in_successor(maze[i+1][j]);

if(judge(maze[i-1][j])==0)

in_successor(maze[i-1][j]);

if(judge(maze[i][j+1])==0)

in_successor(maze[i][j+1]);

}

else if(j==6)//若为第七列的元素(不在角上),则判断左边,上边和上边

{

if(judge(maze[i+1][j])==0)

in_successor(maze[i+1][j]);

if(judge(maze[i-1][j])==0)

in_successor(maze[i-1][j]);

if(judge(maze[i][j-1])==0)

in_successor(maze[i][j-1]);

}

else//若为中将的元素,则判断四个方向的节点

{

if(judge(maze[i][j-1])==0)

in_successor(maze[i][j-1]);

if(judge(maze[i][j+1])==0)

in_successor(maze[i][j+1]);

if(judge(maze[i-1][j])==0)

in_successor(maze[i-1][j]);

if(judge(maze[i+1][j])==0)

in_successor(maze[i+1][j]);

}

while(s2->next!=successor)//对所有的successor节点进行下列操作

{

maze[s2->fnode.x][s2->fnode.y].g=bestnode->fnode.g+bestnode->fnode.h;//计算g(suc)=g(bes)+h(bes,suc)

if(s2->fnode.sign==1)//若在open表中,则置为old,记下较小的g,并从open表中移出,放入closed表中

{

s2->fnode.old=1;

if(s2->fnode.gfnode.x][s2->fnode.y].g)

{

maze[s2->fnode.x][s2->fnode.y].g=s2->fnode.g;

maze[s2->fnode.x][s2->fnode.y].f=maze[s2->fnode.x][s2->fnode.y].g+maze[s2->fnode.x][s2->fnode.y].h;

out_open(maze[s2->fnode.x][s2->fnode.y]);

in_closed(maze[s2->fnode.x][s2->fnode.y]);

maze[s2->fnode.x][s2->fnode.y].old=0;

}

else

continue;

}

else if(s2->fnode.sign==2)//若在closed表中,则置为old,记下较小的g,并将old从closed表中移出,将较小的g的节点放入closed表中

{

s2->fnode.old=1;

if(s2->fnode.gfnode.x][s2->fnode.y].g)

{

maze[s2->fnode.x][s2->fnode.y].g=s2->fnode.g;

maze[s2->fnode.x][s2->fnode.y].f=maze[s2->fnode.x][s2->fnode.y].g+maze[s2->fnode.x][s2->fnode.y].h;

out_closed(maze[s2->fnode.x][s2->fnode.y]);

in_closed(maze[s2->fnode.x][s2->fnode.y]);

maze[s2->fnode.x][s2->fnode.y].old=0;

}

else

continue;

}

else//若即不再open表中也不在closed表中,则将此节点放入open表中,并计算此节点的f值

{

in_open(maze[s2->fnode.x][s2->fnode.y]);

maze[s2->fnode.x][s2->fnode.y].f=maze[s2->fnode.x][s2->fnode.y].g+maze[s2->fnode.x][s2->fnode.y].h;

}

s2=s2->next;

}

s2=successor;

}

else

printf("error!!This maze does not have the answer!");

return(0);

}

实验内容：

以一个m × n的长方阵表示迷宫，0 和1 分别表示迷宫中的通路和障

碍。设计一个程序，对任意设定的迷宫，求出一条从入口到出口的通

路，或得出没有通路的结论。

要求：首先实现一个顺序或链表做存储结构的栈类型，然后编写一个

求解迷宫的非递归程序。求得的通路以三元组(i, j, d)的形式输出，其

中：(i, j)表示迷宫的坐标，d 表示走到下一坐标的方向。如对下面的

迷宫，输出的一条通路为：（1，1，1），（1，2，2），（2，2，2），（3，

2，3），（3，1，2），…...

迷宫约定， x 方向为行方向，y 方向为列方向，迷宫开始坐标(左上

角)为（1,1）。

基本相同；#include

#include

#include

typedef struct QElemType

{

int x,y;

struct QElemType *parent;//用于存储节点的前一个节点

} QElemType;

typedef struct QNode//队列节点

{

QElemType *data;

struct QNode *next;

} QNode, *QueuePtr;

typedef struct

{

QueuePtr front;

QueuePtr rear;

} LinkQueue;

void InitQueue(LinkQueue *Q)//创建队列

{

Q->front=Q->rear=(QueuePtr)malloc(sizeof(QNode));

Q->rear->next = NULL;

//Q->front=Q->rear=NULL;

}

void EnQueue(LinkQueue *Q, QElemType *e)//将元素入队

{

QueuePtr p;

p=(QueuePtr)malloc(sizeof(QNode));

p->data=e;

p->next=NULL;

Q->rear->next=p;

Q->rear=p;

}

QElemType *DeQueue(LinkQueue *Q)//将元素出对

{

QElemType *e;

QueuePtr p;

p=Q->front->next;

e=p->data;

Q->front->next=p->next;

if(Q->rear==p)

Q->rear=Q->front;

free(p);

return (e);

}

int QueueEmpty(LinkQueue *Q)//判断队列是否为空

{

if(Q->front==Q->rear )

return 1;

else

return 0;

}

QElemType *NextPos(QElemType *e,int i)//节点的下一个位置

{

QElemType *t = (QElemType *)malloc(sizeof(QElemType));

*t = *e;

switch(i)

{

case 1:t->y=t->y+1;break;

case 2:t->x=t->x+1;break;

case 3:t->y=t->y-1;break;

case 4:t->x=t->x-1;break;

}

return (t);

}

QElemType *MazePath(int maze[][10],LinkQueue *Q)//迷宫函数

{

int i;

QElemType *e, *p;

e = (QElemType *)malloc(sizeof(QElemType));

// InitQueue(&Q);

e->x=1;//入口位置，即为第一个节点

e->y=1;

e->parent=NULL; //第一个节点的前一个节点赋值为空

EnQueue(Q, e);//将第一个节点入队

while(!QueueEmpty(Q))

{

e=DeQueue(Q); //把元素出对，并赋值给e

if(e->x==8&&e->y==8)//出口位置，直接返回最后一个节点

return e;

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

{//将四个方向能走通的位置的节点入队，并将其的parent指向上一个节点

p=NextPos(e,i);

p->parent=e;

if(maze[p->x][p->y]==1)

{

maze[p->x][p->y]=2;

EnQueue(Q,p);

}

else

{

free(p);

p = NULL;

}

}

}

printf("zhao bu dao");//找不到路径

return NULL;

}

void main()//主函数

{

LinkQueue Q;

QElemType *p, *t;

int maze[10][10]=//其中1为能走通

{{0,0,0,0,0,0,0,0,0,0},

{0,1,1,0,1,1,1,0,1,0},

{0,1,1,0,1,1,1,0,1,0},

{0,1,1,1,1,0,0,1,1,0},

{0,1,0,0,0,1,1,1,1,0},

{0,1,1,1,0,1,1,1,1,0},

{0,1,0,1,1,1,0,1,1,0},

{0,1,0,0,0,1,0,0,1,0},

{0,0,1,1,1,1,1,1,1,0},

{0,0,0,0,0,0,0,0,0,0}

};

InitQueue(&Q);

p=MazePath(maze,&Q);//e即为最后一个节点

while(p)//回溯寻找路径

{

printf("(%d,%d),",p->x,p->y);

t = p->parent;

free(p);

p = t;

}

getchar();

}

实验四

实验学时 2学时

编写一个字符串操作函数int Index( String S1, String S2, int start_Pos)，实现在字符母串S1中对子串S2位置的定位, 并把该位置的信息返回。要求：第一个字符的下标从1开始，如果没有匹配项，返回-1.

背景知识：字符串结构的实现及匹配操作

目的要求：

1. 掌握字符串结构的特点；

2. 掌握字符串匹配操作的意义及实现；

#include

int StrLen(char s[])

{

    int i = 0;

    while(s != '\0')

    {

        i++;

    }

    return i;

}

int FindeStrIndex(char *s1, char *s2)

{

    int i;

    int j;

    int index =0;

    int count = StrLen(s2); //得到s2有多少个字符

    for(i = 0; s1 != '\0'; i++)

    {

        j = 0;

        if(s1 == s2[ j ])

        {

            if(count == 1)

            {

                index = i;

                break;

            }

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

            {

                if(s2[j] != s1[++i])

                {

                    index = -1;

                    break;

                }

                index = (--i);

            }

            if(index != -1)//不等-1表示找到了，跳出循环

                break;

        }

    }

    return index;

}

void main()

{

    char s1[]="abcd1235";

    char s2[]="d1";

    char s3[]= "3";

    int i = FindeStrIndex(s1,s2);

    if(i != -1)

        printf("下标是：%d",i);

    else

        printf("找不到");

    printf("\n");

    i = FindeStrIndex(s1,s3);

    if(i != -1)

        printf("下标是：%d",i);

    else

        printf("找不到");

    getchar();

}