数据结构课程设计-农夫过河-实验报告.

合集下载

数据结构课程设计报告（农夫过河）

数据结构课程设计报告（农夫过河）第一篇：数据结构课程设计报告(农夫过河)目录引言...................................................2 问题描述..............................................3 基本要求 (3)2.1为农夫过河问题抽象数据模型体会数据模型在问题求解中的重要性；........3 2.2设计一个算法求解农夫过河问题，并输出过河方案；......................3 3 概要设计 (3)3.1 数据结构的设计。

....................................................3 3.1.1农夫过河问题的模型化.............................................3 3.1.2 算法的设计 (4)4、运行与测试 (6)5、总结与心得..........................................7 附录...................................................7 参考文献. (13)引言所谓农夫过河问题是指农夫带一只狼、一只羊和一棵白菜在河南岸, 需要安全运到北岸。

一条小船只能容下他和一件物品, 只有农夫能撑船。

问农夫怎么能安全过河, 当然狼吃羊, 羊吃白菜, 农夫不能将这两种或三种物品单独放在河的一侧, 因为没有农夫的照看, 狼就要吃羊, 而羊可能要吃白菜? 这类问题的实质是系统的状态问题, 要寻求的是从初始状态经一系列的安全状态到达系统的终止状态的一条路径。

1 问题描述一个农夫带一只狼、一棵白菜和一只羊要从一条河的南岸过到北岸，农夫每次只能带一样东西过河，但是任意时刻如果农夫不在场时，狼要吃羊、羊要吃白菜，请为农夫设计过河方案。

基本要求2.1为农夫过河问题抽象数据模型体会数据模型在问题求解中的重要性；2.2设计一个算法求解农夫过河问题，并输出过河方案；概要设计3.1 数据结构的设计。

数据结构实验-农夫过河问题

农夫过河问题一、实验目的掌握广度优先搜索策略，并用队列求解农夫过河问题二、实验内容问题描述：一农夫带着一只狼，一只羊和一颗白菜，身处河的南岸，他要把这些东西全部运到北岸，遗憾的是他只有一只小船，小船只能容下他和一件物品。

这里只能是农夫来撑船，同时因为狼吃羊、羊吃白菜、所以农夫不能留下羊和狼或羊和白菜在河的一边，而自己离开；好在狼属肉食动物，不吃白菜。

农夫怎么才能把所有的东西安全运过河呢？实验要求如下：（1）设计物品位置的表示方法和安全判断算法；（2）设计队列的存储结构并实现队列的基本操作（建立空队列、判空、入队、出队、取对头元素），也可以使用STL中的队列进行代码的编写；（3）采用广度优先策略设计可行的过河算法；（4）输出要求：按照顺序输出一种可行的过河方案；提示：可以使用STL中的队列进行代码编写。

程序运行结果：二进制表示：1111011011100010101100011001，0000三、农夫过河算法流程⏹Step1：初始状态0000入队⏹Step2：当队列不空且没有到达结束状态1111时，循环以下操作：⏹队头状态出队⏹按照农夫一个人走、农夫分别带上三个物品走，循环以下操作：⏹农夫和物品如果在同一岸，则计算新的状态⏹如果新状态是安全的并且是没有处理过的，则更新path[ ]，并将新状态入队⏹当状态为1111时，逆向输出path[ ]数组附录一：STL中队列的使用注：队列，可直接用标准模板库（STL）中的队列。

需要#include<queue>STL中的queue，里面的一些成员函数如下（具体可以查找msdn，搜索queue class）：front：Returns a reference to the first element at the front of the queue.pop：Removes an element from the front of the queuepush：Adds an element to the back of the queueempty：Tests if the queue is empty三、实验代码FarmerRiver.H#ifndef FARMERRIVER_H#define FARMERRIVER_Hint FarmerOnRight(int status); //农夫，在北岸返回1，否则返回0int WorfOnRight(int status); //狼int CabbageOnRight(int status); //白菜int GoatOnRight(int status); //羊int IsSafe(int status); //判断状态是否安全，安全返回1，否则返回0void FarmerRiver();#endifSeqQueue.h#ifndef SEQQUEUE_H#define SEQQUEUE_Htypedef int DataType;struct Queue{int Max;int f;int r;DataType *elem;};typedef struct Queue *SeqQueue;SeqQueue SetNullQueue_seq(int m);int IsNullQueue_seq(SeqQueue squeue);void EnQueue_seq(SeqQueue squeue, DataType x);void DeQueue_seq(SeqQueue);DataType FrontQueue_seq(SeqQueue);#endifFarmerRiver.c#include <stdio.h>#include <stdlib.h>#include "SeqQueue.h"#include "FarmerRiver.h"int FarmerOnRight(int status) //判断当前状态下农夫是否在北岸{return (0!=(status & 0x08));}int WorfOnRight(int status){return (0!=(status & 0x04));}int CabbageOnRight(int status){return (0!=(status & 0x02));}int GoatOnRight(int status){return (0!=(status & 0x01));}int IsSafe(int status) //判断当前状态是否安全{if ((GoatOnRight(status)==CabbageOnRight(status)) &&(GoatOnRight(status)!=FarmerOnRight(status)))return (0); //羊吃白菜if ((GoatOnRight(status)==WorfOnRight(status)) && (GoatOnRight(status)!=FarmerOnRight(status))) return 0; //狼吃羊return 1; //其他状态是安全的}void FarmerRiver(){int i, movers, nowstatus, newstatus;int status[16]; //用于记录已考虑的状态路径SeqQueue moveTo;moveTo = SetNullQueue_seq(20); //创建空列队EnQueue_seq(moveTo, 0x00); //初始状态时所有物品在北岸，初始状态入队for (i=0; i<16; i++) //数组status初始化为-1{status[i] = -1;}status[0] = 0;//队列非空且没有到达结束状态while (!IsNullQueue_seq(moveTo) && (status[15]==-1)){nowstatus = FrontQueue_seq(moveTo); //取队头DeQueue_seq(moveTo);for (movers=1; movers<=8; movers<<=1)//考虑各种物品在同一侧if ((0!=(nowstatus & 0x08)) == (0!=(nowstatus & movers)))//农夫与移动的物品在同一侧{newstatus = nowstatus ^ (0x08 | movers); //计算新状态//如果新状态是安全的且之前没有出现过if (IsSafe(newstatus)&&(status[newstatus] == -1)){status[newstatus] = nowstatus; //记录新状态EnQueue_seq(moveTo, newstatus); //新状态入队}}}//输出经过的状态路径if (status[15]!=-1){printf("The reverse path is: \n");for (nowstatus=15; nowstatus>=0; nowstatus=status[nowstatus]){printf("The nowstatus is: %d\n", nowstatus);if (nowstatus == 0)return;}}elseprintf("No solution.\n");}Sequeue.c#include <stdio.h>#include <stdlib.h>#include "SeqQueue.h"SeqQueue SetNullQueue_seq(int m){SeqQueue squeue;squeue = (SeqQueue)malloc(sizeof(struct Queue));if (squeue==NULL){printf("Alloc failure\n");return NULL;}squeue->elem = (int *)malloc(sizeof(DataType) * m);if (squeue->elem!=NULL){squeue->Max = m;squeue->f = 0;squeue->r = 0;return squeue;}else free(squeue);}int IsNullQueue_seq(SeqQueue squeue){return (squeue->f==squeue->r);}void EnQueue_seq(SeqQueue squeue, DataType x) //入队{if ((squeue->r+1) % squeue->Max==squeue->f) //是否满printf("It is FULL Queue!");else{squeue->elem[squeue->r] = x;squeue->r = (squeue->r+1) % (squeue->Max);}}void DeQueue_seq(SeqQueue squeue) //出队{if (IsNullQueue_seq(squeue))printf("It is empty queue!\n");elsesqueue->f = (squeue->f+1) % (squeue->Max); }DataType FrontQueue_seq(SeqQueue squeue) //求队列元素{if (squeue->f==squeue->r)printf("It is empty queue!\n");elsereturn (squeue->elem[squeue->f]);}main.c#include <stdio.h>#include <stdlib.h>#include "FarmerRiver.h"int main(void){FarmerRiver();return 0;}实验结果：四、实验总结。

农夫过河

农夫过河1、问题描述一农夫带着一只羊、一只狼和一颗白菜过河（从左岸到右岸）。

河边只有一条船，由于船太小，只能装下农夫和他的一样东西。

在无人看管的情况下，狼要吃羊，羊要吃菜。

现所编写的程序是为了解决三样东西平安过河的问题。

现将农夫和这三样东西抽象成四个元素，它们各自分别有0和1状态，且初态是0000，那么所解决的问题便转换为如何将0000从安全状态过渡到1111。

2、设计思路本程序通过将问题抽象成四个元素从0000状态以安全状态转为1111，而使问题模型化。

然后通过建立队列来存储安全到达的中间状态，并且通过定义数组来记录已考虑的状态路径。

相应功能的实现是通过定义函数来实现的。

农夫、狼、白菜、羊的位置的判断是通过定义了函数int Nongfu(int location)，int Lang(int location)，int Baicai(int location)，int Yang(int location)来实现的。

而对于安全状态的判断则是定义了函数int Safe(int location)。

最后就是通过主函数来调用相应的函数以实现程序功能。

在主函数中，首先将初状态（初始位置）存入队列然后通过不断的改变状态以及判断是否安全来逐渐接近最终的状态（1111）。

如果route[15] != - 1，则说明成功到达了安全状态，问题有解；否则问题无解。

3、数据结构设计在前面的叙述中提到本程序会用到队列。

在队列中定义了队列的存储容量，以及队头和队尾指针。

然后定义函数PSeqQueue createEmptyQueue_seq(int m)来创建空队列。

以及函数void InQueue_seq(PSeqQueue queue, int x)，void DeleteQueue_seq(PSeqQueue queue)，int FrontQueue_seq(PSeqQueue queue)来分别实现在队尾插入元素，删除队列头部元素，取队头状态，以代表将新状态入队，删除原先的状态以及取相应的状态。

农夫过河问题(数据结构课设)

#include "stdafx.h"#include <stdio.h>/*0代表在河的这边;1代表在河的对岸*/struct Condition {int farmer;int wolf;int sheep;int cabbage;};/*设置结构体*/struct Condition conditions [100];/*结构体条件数组*/char* action[100];/*字符串数组*/ void takeWolfOver(int i)/*把狼带过去*/ {action[i] = "带狼过去. (wolf)--->对岸";conditions[i+1].wolf=1;conditions[i+1].sheep=conditions[i].sheep;conditions[i+1].cabbage=conditions[i].cabbage;} void takeWolfBack(int i)/*把狼带回来*/{action[i] = "带狼回来. 本岸<---(wolf)";conditions[i+1].wolf=0;conditions[i+1].sheep=conditions[i].sheep;conditions[i+1].cabbage=conditions[i].cabbage;} void takeSheepOver(int i)/*把羊带过去*/{action[i] = "带羊过去. (sheep)--->对岸";conditions[i+1].wolf=conditions[i].wolf;conditions[i+1].sheep=1;conditions[i+1].cabbage=conditions[i].cabbage;} void takeSheepBack(int i)/*把羊带回来*/{action[i] = "带羊回来. 本岸<---(sheep)";conditions[i+1].wolf=conditions[i].wolf;conditions[i+1].sheep=0;conditions[i+1].cabbage=conditions[i].cabbage;} void takeCabbageOver(int i)/*把菜带过去*/{action[i] = "带菜过去. (cabbage)--->对岸";conditions[i+1].wolf=conditions[i].wolf;conditions[i+1].sheep=conditions[i].sheep;conditions[i+1].cabbage=1;} void takeCabbageBack(int i)/*把菜带回来*/{action[i] = "带菜回来. 本岸<---(cabbage)";conditions[i+1].wolf=conditions[i].wolf;conditions[i+1].sheep=conditions[i].sheep;conditions[i+1].cabbage=0;} void getOverBarely(int i)/*过河时的情况*/{action[i] = "空手过去. (barely)--->对岸";conditions[i+1].wolf=conditions[i].wolf;conditions[i+1].sheep=conditions[i].sheep;conditions[i+1].cabbage=conditions[i].cabbage;/*全不动*/} void getBackBarely(int i)/*返回时的情况*/{action[i] = "空手回来. 本岸<---(barely)";conditions[i+1].wolf=conditions[i].wolf;conditions[i+1].sheep=conditions[i].sheep;conditions[i+1].cabbage=conditions[i].cabbage;} void showSolution(int i)/*显示解决方法*/{int c;printf("\n");printf ("%s\n", "解决办法:");for(c=0; c<i; c++){printf ("step%d: %s\n", c+1, action[c]);/*换行输出*/}printf ("%s\n", "Successful!");}void tryOneStep(int i)/*再试一遍*/{int c;int j;if(i>=100)/*检查循环是否出现问题*/{printf("%s\n", "渡河步骤达到100步，出错！");return;}if(conditions[i].farmer==1&&conditions[i].wolf==1&&conditions[i].sheep==1&&conditions[i].cabbage==1)/*检查是否都过河*/{showSolution(i);/*是的，都过河了.返回*/return;}if((conditions[i].farmer!=conditions[i].wolf &&conditions[i].wolf==conditions[i].sheep)||(conditions[i].farmer!=conditions[i].sheep && conditions[i].sheep==conditions[i].cabbage))/*检查是否丢失，出错*/{/*不，狼会吃掉羊，或者羊会吃掉菜的*/return;}/*检查条件是否满足*/for (c=0; c<i; c++){if(conditions[c].farmer==conditions[i].farmer&&conditions[c].wolf==conditions[i].wolf&&conditions[c].sheep==conditions[i].sheep&&conditions[c].cabbage==conditions[i].cabbage) {return;}}j=i+1;if(conditions[i].farmer==0)/*农夫在河这边*/{conditions[j].farmer=1;getOverBarely(i);tryOneStep(j);if(conditions[i].wolf==0)/*如果狼没带过去*/{takeWolfOver(i);tryOneStep(j);}if(conditions[i].sheep==0){takeSheepOver(i);tryOneStep(j);}if(conditions[i].cabbage==0){takeCabbageOver(i);tryOneStep(j);}}else{conditions[j].farmer=0;getBackBarely(i);tryOneStep(j);if(conditions[i].wolf==1){takeWolfBack(i);tryOneStep(j);}if(conditions[i].sheep==1){takeSheepBack(i);tryOneStep(j);}if(conditions[i].cabbage==1){takeCabbageBack(i);tryOneStep(j);}}} int main()/*主函数*/{printf("问题：农夫过河。

农夫过河问题

课程设计题目：农夫过河一．问题描述一个农夫带着一只狼、一只羊和一箩白菜，身处河的南岸。

他要把这些东西全部运到北岸。

他面前只有一条小船，船只能容下他和一件物品，另外只有农夫才能撑船。

过河有以下规则：(1)农夫一次最多能带一样东西（或者是狼、或者是羊、或者是白菜）过河；(2)当农夫不在场是狼会吃羊；(3)当农夫不在场是羊会吃掉白菜。

现在要求为农夫想一个方案，能将3样东西顺利地带过河。

从出事状态开始，农夫将羊带过河，然后农夫将羊待会来也是符合规则的，然后农夫将羊带过河仍然是符合规则的，但是如此这般往返，搜索过程便进入了死循环，因此，在这里，采用改进的搜索算法进行搜索。

二．基本要求(1)为农夫过河问题抽象数据类型，体会数据模型在问题求解中的重要性；(2)要求利用数据结构的方法以及Ｃ＋＋的编程思想来完成问题的综合设计；(3)在问题的设计中，使用深度优先遍历搜索方式，避免死循环状态；(4)设计一个算法求解农夫过河问题，并输出过河方案；(5)分析算法的时间复杂度。

三．概要设计(1)数据结构的设计typedef struct // 图的顶点{int farmer; // 农夫int wolf; // 狼int sheep; // 羊int veget; // 白菜}Vertex;设计Vertex结构体的目的是为了存储农夫、狼、羊、白菜的信息，因为在遍历图的时候，他们的位置信息会发生变化，例如1111说明他们都在河的北岸，而0000说明他们都在河的南岸。

t ypedef struct{int vertexNum; // 图的当前顶点数Vertex vertex[VertexNum]; // 顶点向量（代表顶点）bool Edge[VertexNum][VertexNum]; // 邻接矩阵. 用于存储图中的边，其矩阵元素个数取决于顶点个数，与边数无关}AdjGraph; // 定义图的邻接矩阵存储结构存储图的方法是用邻接矩阵，所以设计一个简单的AdjGraph结构体是为了储图的顶点数与边数，农夫过河问题我采用的是图的深度优先遍历思想。

农夫过河问题

一、题目:农夫过河问题二、目的与要求1、目的：通过布置具有一定难度的实际程序设计项目，使学生进一步理解和掌握课堂上所学各种基本抽象数据类型的逻辑结构、存储结构和操作实现算法，以及它们在程序中的使用方法；使学生掌握分析问题，求解问题的方法并提高学生设计编程实现的能力。

2、要求：基本要求：1.要求利用C\C++语言来完成系统的设计；2.突出C语言的函数特征（以多个函数实现每一个子功能）或者C++语言面向对象的编程思想；3.画出功能模块图；4.进行简单界面设计，能够实现友好的交互；5.具有清晰的程序流程图和数据结构的详细定义；6.熟练掌握C语言或者C++语言的各种操作。

创新要求：在基本要求达到后，可进行创新设计，如系统用户功能控制，改进算法的实现，实现友好的人机交互等等三、问题描述和求解方法：1 、问题描述要求设计实现农夫过河问题（农夫带着一只狼，一只养，一棵白菜，一次只能带一个东西）如何安全过河。

2 、问题的解决方案：可以用栈与队列、深度优先搜索算法及广度优先搜索算法相应的原理去解决问题。

1)实现四个过河对象（农夫、白菜、羊和狼）的状态，可以用一个四位二进制数来表示，0表示未过河，1表示已经过河了。

2)过河的对象必须与农夫在河的同一侧，可以设计函数来判断。

3)防止状态往复，即农夫将一个东西带过去又带回来的情况发生，需将所有可能的状态进行标定。

4)可用深度优先搜索算法及广度优先搜索算法去解题。

四、解题过程1.分析程序的功能要求，划分程序功能模块。

2.画出系统流程图。

3.代码的编写。

定义数据结构和各个功能子函数。

4.程序的功能调试。

5.完成系统总结报告以及使用说明书五、进度安排此次课程设计时间为一周，分以下几个阶段完成：1.选题与搜集资料：每人选择一题，进行课程设计课题的资料搜集。

2.分析与概要设计：根据搜集的资料，进行程序功能与数据结构分析，并选择合适的数据结构、并在此基础上进行实现程序功能的算法设计。

数据结构实验-农夫过河问题

这里只能是农夫来撑船，同时因为狼吃羊、羊吃白菜、所以农夫不能留下羊和狼或羊和白菜在河的一边，而自己离开；好在狼属肉食动物，不吃白菜。

需要#include<queue>STL中的queue，里面的一些成员函数如下（具体可以查找msdn，搜索queue class）：front：Returns a reference to the first element at the front of the queue.pop：Removes an element from the front of the queuepush：Adds an element to the back of the queueempty：Tests if the queue is empty三、实验代码FarmerRiver.H#ifndef FARMERRIVER_H#define FARMERRIVER_Hint FarmerOnRight(int status); //农夫，在北岸返回1，否则返回0int WorfOnRight(int status); //狼int CabbageOnRight(int status); //白菜int GoatOnRight(int status); //羊int IsSafe(int status); //判断状态是否安全，安全返回1，否则返回0void FarmerRiver();#endifSeqQueue.h#ifndef SEQQUEUE_H#define SEQQUEUE_Htypedef int DataType;struct Queue{int Max;int f;int r;DataType *elem;};typedef struct Queue *SeqQueue;SeqQueue SetNullQueue_seq(int m);int IsNullQueue_seq(SeqQueue squeue);void EnQueue_seq(SeqQueue squeue, DataType x);void DeQueue_seq(SeqQueue);DataType FrontQueue_seq(SeqQueue);#endifFarmerRiver.c#include <stdio.h>#include <stdlib.h>#include "SeqQueue.h"#include "FarmerRiver.h"int FarmerOnRight(int status) //判断当前状态下农夫是否在北岸{return (0!=(status & 0x08));}int WorfOnRight(int status){return (0!=(status & 0x04));}int CabbageOnRight(int status){return (0!=(status & 0x02));}int GoatOnRight(int status){return (0!=(status & 0x01));}int IsSafe(int status) //判断当前状态是否安全{if ((GoatOnRight(status)==CabbageOnRight(status)) && (GoatOnRight(status)!=FarmerOnRight(status)))return (0); //羊吃白菜if ((GoatOnRight(status)==WorfOnRight(status)) && (GoatOnRight(status)!=FarmerOnRight(status))) return 0; //狼吃羊return 1; //其他状态是安全的}void FarmerRiver(){int i, movers, nowstatus, newstatus;int status[16]; //用于记录已考虑的状态路径SeqQueue moveTo;moveTo = SetNullQueue_seq(20); //创建空列队EnQueue_seq(moveTo, 0x00); //初始状态时所有物品在北岸，初始状态入队for (i=0; i<16; i++) //数组status初始化为-1{status[i] = -1;}status[0] = 0;//队列非空且没有到达结束状态while (!IsNullQueue_seq(moveTo) && (status[15]==-1)){nowstatus = FrontQueue_seq(moveTo); //取队头DeQueue_seq(moveTo);for (movers=1; movers<=8; movers<<=1)//考虑各种物品在同一侧if ((0!=(nowstatus & 0x08)) == (0!=(nowstatus & movers)))//农夫与移动的物品在同一侧{newstatus = nowstatus ^ (0x08 | movers); //计算新状态//如果新状态是安全的且之前没有出现过if (IsSafe(newstatus)&&(status[newstatus] == -1)){status[newstatus] = nowstatus; //记录新状态EnQueue_seq(moveTo, newstatus); //新状态入队}}}//输出经过的状态路径if (status[15]!=-1){printf("The reverse path is: \n");for (nowstatus=15; nowstatus>=0; nowstatus=status[nowstatus]){printf("The nowstatus is: %d\n", nowstatus);if (nowstatus == 0)return;}}elseprintf("No solution.\n");}Sequeue.c#include <stdio.h>#include <stdlib.h>#include "SeqQueue.h"SeqQueue SetNullQueue_seq(int m){SeqQueue squeue;squeue = (SeqQueue)malloc(sizeof(struct Queue));if (squeue==NULL){printf("Alloc failure\n");return NULL;}squeue->elem = (int *)malloc(sizeof(DataType) * m);if (squeue->elem!=NULL){squeue->Max = m;squeue->f = 0;squeue->r = 0;return squeue;}else free(squeue);}int IsNullQueue_seq(SeqQueue squeue){return (squeue->f==squeue->r);}void EnQueue_seq(SeqQueue squeue, DataType x) //入队{if ((squeue->r+1) % squeue->Max==squeue->f) //是否满printf("It is FULL Queue!");else{squeue->elem[squeue->r] = x;squeue->r = (squeue->r+1) % (squeue->Max);}}void DeQueue_seq(SeqQueue squeue) //出队{if (IsNullQueue_seq(squeue))printf("It is empty queue!\n");elsesqueue->f = (squeue->f+1) % (squeue->Max); }DataType FrontQueue_seq(SeqQueue squeue) //求队列元素{if (squeue->f==squeue->r)printf("It is empty queue!\n");elsereturn (squeue->elem[squeue->f]);}main.c#include <stdio.h>#include <stdlib.h>#include "FarmerRiver.h"int main(void){FarmerRiver();return 0;}实验结果：四、实验总结。

数据结构农夫过河项目课报告

数据结构农夫过河项目课报告数据结构-农夫过河项目课报告-计算机四班第七组项目名称:农夫过河算法与数据结构设计专业班级:计算机科学与技术四班学生姓名:王喆指导教师: 完成日期:2015年12月28日数据结构-农夫过河项目课报告-计算机四班第七组农夫过河算法与数据结构设计摘要农夫过河问题即一个农夫带着一只狼、一只羊和一棵白菜，身处河的南岸,他需要把这些东西全部运到河的北岸。

而他只有一条小船，且这只小船小到只能容下他和一件物品,另外只有农夫能撑船。

农夫不能留下狼和羊自己离开，也不能留下白菜和羊自己离开,更不能留下狼，羊和白菜而独自离开，因为没有农夫的照看,狼就要吃掉羊,而羊又要吃掉白菜。

好在狼是是肉动物，它不吃白菜，问农夫应该采取什么方案才能将所有的东西安全地从河的南岸运到北岸,这类农夫问题是一个传统的数据结构问题,农夫过河问题根据图求解的搜索过程可采用两种不同的策略:一种是图的深度优先遍历搜索，另外一种是广度优先遍历搜索。

如果采用深度优先遍历搜索，则需要采用递归的方式来编写程序，而这种程序的系统的开销比较大，如果采用广度优先搜索，则可以借助队列的方式，这种方式开销较小。

关键字:农夫过河，广度优先遍历搜索，队列，深度优先遍历搜索，递归。

2数据结构-农夫过河项目课报告-计算机四班第七组目录1.前言…………………………………………………………42.设计任务与技术要求………………………………………43.总体设计方案………………………………………………44.数据结构和算法的设计……………………………………55.程序测试与调试(一)……………………………………7 6.程序测试与调试(二)..........................................9 7.程序出现的问题及修改情况....................................14 8.心得与体会.........................................................14 参考文献 (15)3数据结构-农夫过河项目课报告-计算机四班第七组1.前言课程研究项目是《数据结构》课程学习的重要方式之一，也是《数据结构》课程学习的重要组成部分之一。

1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。

一、需求分析描述1、针对实现整个过程需要多步，不同步骤中各个事物所处位置不同的情况，可定义一个结构体来实现对四个对象狼、羊、白菜和农夫的表示。

对于起始岸和目的岸，可以用0或者1来表示，以实现在程序设计中的简便性。

2、题目要求给出四种事物的过河步骤，没有对先后顺序进行约束，这就需要给各个事物依次进行编号，然后依次试探，若试探成功，进行下一步试探。

这就需要使用循环或者递归算法，避免随机盲目运算且保证每种情况均试探到。

3、题目要求求出农夫带一只羊，一条狼和一颗白菜过河的办法，所以依次成功返回运算结果后，需要继续运算，直至求出结果，即给出农夫的过河方案。

4、输出界面要求具有每一步中农夫所带对象及每步之后各岸的物体，需要定义不同的数组来分别存储上述内容，并使界面所示方案清晰简洁。

二、系统架构设计1．设计中首先涉及的就是数据类型的定义，首先，定义一个结构体用来存放农夫、狼、羊、白菜的信息。

具体定义为：struct Condition{int farmer;int wolf;int sheep;int cabbage;};定义了一个结构体数组Condition conditions[100]，定义状态数组用来记录他们过河的状态0：起始岸；1：目的岸;程序中定义的char action100数组用来存放各个物件以及人过河或返回的说明语句。

2．程序中定义的子函数有：2.1 将狼带到目的岸以及带回起始岸的函数takeWolfOver（）和takeWolfBack （）；takeWolfOver（）函数中将conditions[i+1].wolf=1，白菜、羊的状态不变，同时要有action[i]=" take wolf over."将狼带到目的岸语句；takeWolfBack（）函数中将conditions[i+1].wolf=0，白菜、羊的状态不变，同时要有action[i]=" take wolf back."将狼带回起始岸语句。

2.2 将羊带到目的岸以及带回起始岸的函数takeSheepOver（）和takeSheepBack（）；takeSheepOver（）函数中将conditions[i+1].sheep=1，白菜、狼的状态不变，同时要有action[i]=" take sheep over."将羊带到目的岸语句；takeSheepBack（）函数中将conditions[i+1].sheep=0，白菜、狼的状态不变，同时要有action[i]=" take sheep back."将羊带回起始岸语句。

2.3 将白菜带到目的岸以及带回起始岸的函数takeCabbageOver和takeCabbageBack（）；takeCabbageOver（）函数中将conditions[i+1].cabbage=1，羊、狼的状态不变，同时要有action[i]=" take cabbage over."将白菜带到目的岸语句。

takeCabbageBack（）；函数中将conditions[i+1].cabbage=0，羊、狼的状态不变，同时要action[i]=" take cabbage back."将白菜带回起始岸语句。

2.4 getOverBarely（）函数是用来完成一个人单独过河的操作，调用该函数时action[i]=" get over barely."赋值人单独回到目的岸，狼、羊、白菜的状态保持不变。

2.5 getBackBarely（）函数是用来完成一个人单独回到起始岸的操作，调用该函数时action[i]=" get back barely."赋值人单独回起始岸，狼、羊、白菜的状态保持不变。

2.6 输出过河的每一个步骤以及完成每一步之后人、狼、羊、白菜的状态这一动作是由showResult（）函数来完成的，2.7 tryOneStep是本次设计的核心程序，上面提到的所有子程序之间都是相互独立的，但是在tryOneStep函数中都要调用上面的子函数。

3．程序流程图：3.1图1. 主函数的流程3.2tryOneStep函数工作的流程图如下：图2.tryOneStep （）函数的流程三、系统实现过程编写好各个子程序后，在main （）函数中首先将人，狼，羊，白菜的初始状态都置为0，接下来调用tryOneStep （）函数，同时0作为实参传给tryOneStep（）函数。

1． tryOneStep （）函数实现过程如下：1.1 首先，定义两个int 型变量c ，j 。

1.2接下来判断四者的状态是否都为1，若都为1说明已经过河成功了，之后调用showResult （）函数，输出相关信息，在由return 返回到调用处。

程序执行结束。

1.3再判断是否有非法情况出现，即：羊单独和白菜在一起或狼和羊单独在一起，具体实现的语句if(conditions[i].farmer!=conditions[i].wolf&&conditions[i].wolf==conditions[i].sheep||conditions[i].farmer!=conditions[i].sheep&&conditions[i].sheep==condi tions[i].cabbage){return;} 如果条件成立的话执行if语句即执行return 返回到调用点，否则，向下继续执行。

1.4 再通过 for(c=0;c<i;c++){if(conditions[c].farmer==conditions[i].farmer&&conditions[c].wolf==conditions[i].wolf&&conditions[c].sheep==conditions[i].sheep&&conditions[c].cabbage==conditions[i].cabbage){return;}} 判断是否有重复状态1.5 j=i+11.6判断conditions[i].farmer是否为0，如果不为0，则跳转到（1.10）接着执行；若为0，则设置为1，调用getOverBarely(i)，接着tryOneStep(j)，调用tryOneStep(j)时就是重复执行整个调用过程，直到其中有条件不成立时跳到该调用处。

1.7 执行1.6以后跳回到调用点后，接着判断狼是否还未过河。

即conditions[i].wolf==0是否成立，成立则调用takeWolfOver(i)，再执行tryOneStep(j)递归调用自身但实参已发生变化，直到退回到该调用处，就继续向下执行；若狼已经过河就执行1.9。

1.8判断羊是否还未过河。

即conditions[i].sheep==0是否成立，若过河，则就执行1.9；未过河，则调用takeSheepOver(i)，再执行tryOneStep(j)。

1.9最后判断白菜是否已经过河，未过河则调用takeCabbageOver(i)，再tryOneStep(j)，完成调用后回到该调用处。

1.10若开始conditions[i].farmer=1，则从1.10这里就开始执行，先将conditions[i].farmer设置为0，接着调用getBackBarely(i)，后执行tryOneStep(j)，递归调用，直到退回该处，接着向下执行。

1.11顺序执行conditions[i].wolf==1若成立就执行 takeWolfBack(i)后tryOneStep(j)，直到退回到该调用处，若不成立就直接向下执行。

1.12顺序执行conditions[i].sheep==1若成立就执行 takeSheepBack(i)后tryOneStep(j)，直到退回到该调用处，若不成立就直接向下执行。

1.13顺序执行conditions[i].cabbage==1若成立就执行 takeCabbageBack(i)后tryOneStep(j)，直到退回到该调用处，若不成立就直接向下执行。

2.主函数调用关系如下：图3.函数调用关系四、总结和体会1.刚开始在判断每一种是否安全时走得有点麻烦：开始把每种状态都列出来逐个判断，可时间复杂度较大，经过考虑只要判断两大类即可，第一种是农夫和羊一块，然后再分析其他两种物体的状态。

第二种是两者不在一起，然后再分析其他两种物体的状态。

这样可以很快找出安全状态而且降低了时间复杂度。

2.对本次实验，我得到：以前用c或c++编程，只是注重如何编写函数能够完成所需要的功能，似乎没有明确的战术，只是凭借单纯的意识和简单的语句来堆砌一段程序。

但现在学了《数据结构》后，变成完全不同啦，在编写一个程序之前，自己综合考虑各种因素，首先选取自己需要的数据结构，然后选一种或几种存储结构来具体决定后面的函数主要风格。

3.这次用状态回溯算法，其中主要是递归，以前都不敢用这个，这次尝试着，一步一步都克服啦，这都是很大进步。

五、参考文献（1）严蔚敏吴伟民,数据结构（C语言版）清华大学出版社2011.7（2）徐孝凯数据结构使用教程清华大学出版社1999.12 六、开发环境VC6.0七、源代码//main.cpp#include"farmerwade.h"int main(){cout<<" 数据结构课程设计"<<endl;cout<<" ****************"<<endl;cout<<" 农夫过河"<<endl;conditions[0].farmer=0;conditions[0].wolf=0;conditions[0].sheep=0;conditions[0].cabbage=0;tryOneStep(0);getchar();return 0;}//farmerwade.h//定义一个结构体用来存放农夫、狼、羊、白菜的信息#include <iostream>using namespace std;struct Condition{int farmer;int wolf;int sheep;int cabbage;};//定义状态数组用来记录他们过河的状态0：起始岸；1：目的岸Condition conditions[100];char* action[100]; // 存放各个物体及农夫过河或返回的情况//产生某个动作之后再状态更新void takeWolfOver(int i){action[i]=" take wolf over.";conditions[i+1].wolf=1;conditions[i+1].sheep=conditions[i].sheep;conditions[i+1].cabbage=conditions[i].cabbage;}void takeWolfBack(int i){action[i]=" take wolf back.";conditions[i+1].wolf=0;conditions[i+1].sheep=conditions[i].sheep;conditions[i+1].cabbage=conditions[i].cabbage;}void takeSheepOver(int i){action[i]=" take sheep over.";conditions[i+1].wolf=conditions[i].wolf;conditions[i+1].sheep=1;conditions[i+1].cabbage=conditions[i].cabbage; }void takeSheepBack(int i){action[i]=" take sheep back.";conditions[i+1].wolf=conditions[i].wolf;conditions[i+1].sheep=1;conditions[i+1].cabbage=conditions[i].cabbage; }void takeCabbageOver(int i){action[i]=" take cabbage over.";conditions[i+1].wolf=conditions[i].wolf;conditions[i+1].sheep=conditions[i].sheep;conditions[i+1].cabbage=1;}void takeCabbageBack(int i){action[i]=" take cabbage back.";conditions[i+1].wolf=conditions[i].wolf;conditions[i+1].sheep=conditions[i].sheep;conditions[i+1].cabbage=0;}//农夫单独来回void getOverBarely(int i){action[i]=" get over barely.";conditions[i+1].wolf=conditions[i].wolf;conditions[i+1].sheep=conditions[i].sheep;conditions[i+1].cabbage=conditions[i].cabbage;}void getBackBarely(int i){action[i]=" get back barely.";if(i>=100){cout<<"index reached 100,something is wrong!"<<endl;return ;}conditions[i+1].wolf=conditions[i].wolf;conditions[i+1].sheep=conditions[i].sheep;conditions[i+1].cabbage=conditions[i].cabbage;}void showResult(int i){int c;for(c=0;c<i;c++){cout<<c+1<<"."<<action[c]<<endl;}cout<<endl<<"All came to the other side!"<<endl;}void tryOneStep(int i){int c,j;//到达成功状态if(conditions[i].farmer==1&&conditions[i].wolf==1&&conditions[i].sheep==1&&conditions[i].cabbage==1){showResult(i);return;}//到达非法状态if(conditions[i].farmer!=conditions[i].wolf&&conditions[i].wolf==conditions[i].sheep||conditions[i].farmer!=conditions[i].sheep&&conditions[i].sheep==conditions[i].cabbage) {return;}//判断是否有重复状态for(c=0;c<i;c++){if(conditions[c].farmer==conditions[i].farmer&&conditions[c].wolf==conditions[i].wolf&&conditions[c].sheep==conditions[i].sheep&&conditions[c].cabbage==conditions[i].cabbage) {return;}}j=i+1;if(conditions[i].farmer==0){conditions[j].farmer=1;getOverBarely(i);tryOneStep(j);if(conditions[i].wolf==0){takeWolfOver(i);tryOneStep(j);}if(conditions[i].sheep==0){takeSheepOver(i);tryOneStep(j);}if(conditions[i].cabbage==0){takeCabbageOver(i);tryOneStep(j);}}else{conditions[j].farmer=0;getBackBarely(i);tryOneStep(j);if(conditions[i].wolf==1){takeWolfBack(i);tryOneStep(j);}if(conditions[i].sheep==1){takeSheepBack(i);tryOneStep(j);}if(conditions[i].cabbage==1){takeCabbageBack(i);tryOneStep(j);}}}。