精华内容
下载资源
问答
  • 数据结构 迷宫算法

    2018-12-20 12:49:57
    用栈来求解迷宫数据结构实验。求解迷宫的代码来自书上,迷宫只能在源代码上修改。
  • 数据结构迷宫算法

    2014-03-07 21:14:23
    学习数据结构时候编写的迷宫算法, 欢迎批评指正相互学习!
  • c语言数据结构迷宫算法 有详细的注释 动态堆栈的详细
  • 包含了递归算法和非递归算法的实现、程序有注释、阅读很方便
  • 数据结构课程设计必备文档!迷宫算法!利用栈
  • 新手写的简单的严蔚敏数据结构迷宫算法,是对原版的补充,花了不少时间,虽然很简单,但是这个过程学了不少东西,拿来分享,有不足的多多指教!
  • 按照《数据结构算法与应用C++语言描述》第九章栈的思路来实现解法。 迷宫内部主要有四个函数。welcome函数是欢迎界面,inputMaze函数是输入迷宫,findPath是寻找迷宫解法,outputPath是输出迷宫解法。 #include &...

    一、栈的算法查找迷宫解法

    1.代码

    按照《数据结构、算法与应用C++语言描述》第九章栈的思路来实现解法。

    迷宫内部主要有四个函数。welcome函数是欢迎界面,inputMaze函数是输入迷宫,findPath函数是寻找迷宫解法,outputPath函数是输出迷宫解法。

    #include <iostream>
    #include "Maze.h"
    
    using namespace std;
    
    int main()
    {
        Maze m;
        m.welcome();
        m.inputMaze();
        m.findPath();
        m.outputPath();
    
        return 0;
    }
    

    记录当前位置的类position.h

    #ifndef POSITION_H
    #define POSITION_H
    
    #include <iostream>
    
    using namespace std;
    
    class position
    {
    public:
    	position()
    	{
    		this->row = 0;
    		this->col = 0;
    	}
    	position(int r, int c)
    	{
    		this->row = r;
    		this->col = c;
    	}
    	~position() {}
    
    	int row;
    	int col;
    };
    
    #endif // !POSITION_H
    
    

    迷宫类Maze.h

    #ifndef MAZE_H
    #define MAZE_H
    
    #include <iostream>
    #include <stack>
    #include "position.h"
    
    using namespace std;
    
    class Maze
    {
    public:
    	Maze();
    	~Maze();
    	void welcome();
    	void inputMaze();
    	void findPath();
    	void outputPath();
    
    private:
    	int m;  //迷宫行数
    	int n;  //迷宫列数
    	int** maze;  //二维指针存取迷宫,(m+2)*(n+2)
    	stack<position>* path;  //迷宫路线
    };
    
    #endif // !MAZE_H
    
    

    迷宫类的实现

    #include "Maze.h"
    
    Maze::Maze()
    {
    	m = 0;
    	n = 0;
    }
    
    Maze::~Maze()
    {
    	if (maze != NULL)
    	{
    		for (int i = 0; i < m + 2; ++i)
    		{
    			delete[] maze[i];
    		}
    		delete[] maze;
    		maze = NULL;
    	}
    
    	if (path != NULL)
    	{
    		delete path;
    		path = NULL;
    	}
    }
    
    void Maze::welcome()
    {
    	cout << "Welcome To A MAZE" << endl;
    }
    
    void Maze::inputMaze()
    {//返回存取迷宫的二维指针
    	cout << "请输入迷宫的长和宽:" << endl;
    	cin >> m >> n;
    	
    	this->maze = new int* [m + 2];
    	for (int i = 0; i < m + 2; ++i)
    	{
    		maze[i] = new int[n + 2];
    		maze[i][0] = maze[i][n + 1] = 1;  //第一列和最后一列为墙
    	}
    
    	for (int i = 0; i < n + 2; ++i)
    	{
    		maze[0][i] = maze[m + 1][i] = 1;  //第一行和最后一行为墙
    	}
    
    	cout << "请输入迷宫内容:\n";
    	//输入迷宫内容,0代表可通,1代表不通
    	for (int i = 1; i < m + 1; ++i)
    	{
    		for (int j = 1; j < this->n + 1; ++j)
    		{
    			cin >> maze[i][j];
    		}
    	}
    }
    
    void Maze::findPath()
    {
    	//定义当前位置移动的4个方向,第0列为行偏移量,第1列为列偏移量
    	int move[4][2] = { {0,1},{1,0},{0,-1},{-1,0} };   //右,下,左,上
    
    	path = new stack<position>; // 存储路径信息
    	position here(1, 1);  //起始位置
    	maze[1][1] = 1;  //防止回到入口
    	int option = 0;  //可选的方向,右、下、左、上=(0,1,2,3)
    	int max_option = 3;  //方向的选择范围
    
    	while (here.row != m || here.col != n)  //没走到迷宫出口
    	{
    		//找到要移动的相邻一步
    		int r = 0, c = 0;
    		while (option <= max_option)
    		{
    			r = here.row + move[option][0];
    			c = here.col + move[option][1];
    			if (maze[r][c] == 0)  //可以走通
    			{
    				break;
    			}
    			++option;  //寻找下一个方向
    		}
    
    		if (option <= max_option)  //可以接着走通的情况
    		{
    			path->push(here);  //更新路径
    			//here更新位置
    			here.row = r;
    			here.col = c;
    
    			maze[here.row][here.col] = 1;  //防止往下寻找时重复访问到此位置
    			option = 0;
    		}
    		else  //当走不通时,可以把当前位置置1封死路,返回上一位置
    		{
    			if (path->empty())
    			{
    				cout << "There Is No Path For This Maze!" << endl;
    				return;
    			}
    			else
    			{
    				//返回重新搜索
    				position next = path->top();
    				path->pop();
    				//将当前位置封死,避免重复搜索
    				maze[here.row][here.col] = 1;
    				here = next;
    				option = 0;
    			}
    		}
    	}
    	path->push(here);  //出口位置入栈
    
    	cout << "I Find The Path For This Maze!" << endl;
    	return;
    }
    
    void Maze::outputPath()
    {
    	if (path == NULL)
    	{
    		cout << "There Is No Path For This Maze!" << endl;
    		return;
    	}
    
    	char** mazePath = new char* [m];
    	//拷贝迷宫到mazePath
    	for (int i = 0; i < m; ++i)
    	{
    		mazePath[i] = new char[n];
    		for (int j = 0; j < n; ++j)
    		{//四周的墙去掉
    			if (maze[i + 1][j + 1] == 0)
    			{
    				mazePath[i][j] = '0';
    			}
    			else if (maze[i + 1][j + 1] == 1)
    			{
    				mazePath[i][j] = '1';
    			}
    		}
    	}
    	//拷贝走出迷宫的路线到mazePath
    
    	position tmp;
    	while (!path->empty())
    	{
    		tmp = path->top();
    		path->pop();
    		mazePath[tmp.row - 1][tmp.col - 1] = '*';  //去除墙
    	}
    
    	//打印输出迷宫路线
    	for (int i = 0; i < m; ++i)
    	{
    		for (int j = 0; j < n; ++j)
    		{
    			cout << mazePath[i][j] << " ";
    		}
    		cout << endl;
    
    		delete[] mazePath[i];   //删除指针空间
    	}
    
    	delete[] mazePath;  //删除指针空间
    }
    

    内部实现算法注释已经写得很清楚了,注意最后输出的迷宫算法将查找路线过程也一并显示了,查找过程走错的路线都置为1了。

    2.测试用例

    测试1:
    请输入迷宫的长和宽:
    5 5
    请输入迷宫内容:
    0 1 1 0 0
    0 0 1 1 0
    1 0 0 1 1
    1 0 0 1 0
    1 1 0 0 0
    

    测试结果:
    测试结果

    测试2:
    请输入迷宫的长和宽:
    9 8
    请输入迷宫内容:
    0 0 1 0 0 0 1 0
    0 0 1 0 0 0 1 0
    0 0 0 0 1 1 0 1
    0 1 1 1 0 0 1 0
    0 0 0 1 0 0 0 0
    0 1 0 0 0 1 0 1
    0 1 1 1 1 0 0 1
    1 1 0 0 0 1 0 1
    1 1 0 0 0 0 0 0
    

    测试结果:
    测试结果

    展开全文
  • /* ****迷宫算法求解************* */ /**计目标:教学演示**************/ #include #define rows 10 #define cols 10 typedef struct {int row; int col; }PosType;/* //坐标点结构 */ typedef struct {int ...
  • 该程序实现严蔚敏的数据结构课本上的迷宫算法,并采用文件的输入输出。
  • c++实现的走迷宫算法,实验报告中对算法做了详细说明。
  • 数据结构算法之走迷宫

    千次阅读 2017-07-10 20:21:16
    数据结构算法 Java实现走迷宫

    1.走迷宫算法思想
    走迷宫有很多种实现方式,包括:
    (1)递归:
    a.创建一个存储通路结点的栈Stack。
    b.从矩阵的第一个结点(0,0)开始,将(0,0)结点压入栈中,顺时针从右->下->左->上寻找通路结点(这里我的设计是值为1的就是通路,值为0的就不是通路,这里的通路结点是要在通向目的结点那条道上的结点),将每个通路结点压入栈中,直到找到的通路结点是目的结点。
    c.设置一个判断是否已经访问过的数组boolean visited[][],如果结点已经访问过,将数组中对应位置的值设置为true。
    d.对于通路结点的选择,要判断是否在边界内,以及是否曾经压入栈中,也就是是否曾经访问过。
    (2)深度优先搜索遍历
    (3)广度优先搜索遍历
    2.算法代码实现

    /**
     * @description 迷宫结点
     * @author liuffei
     * @date 2017-07
     */
    public class MazeNode {
    
        private int row;//结点行数
        private int col;//结点列数
    
        public MazeNode(int row,int col){
            this.row = row;
            this.col = col;
        }
    
        public int getRow() {
            return row;
        }
    
        public void setRow(int row) {
            this.row = row;
        }
    
        public int getCol() {
            return col;
        }
    
        public void setCol(int col) {
            this.col = col;
        }
    }
    import java.util.Stack;
    
    /**
     * @description 寻找迷宫的出路
     * @author liuffei
     * @date 2017-06-16 
     */
    public class MazeRoute {
    
        //创建存储路过结点的栈
        public Stack<MazeNode> stack = new Stack<MazeNode>();
    
        //maze中的结点为1表示是通路,0表示不是通路
        public  Stack findRoute(int[][] maze){
            MazeNode beginNode = new MazeNode(0,0);//进入结点
            stack.push(beginNode);
            //对于一个结点,从它的右-下-左-上顺时针进行遍历。判断当前节点的邻结点是否为通路,如果是的话,就压入栈中,继续寻找下一个通路。
            int x = maze.length;//迷宫矩阵的行数
            int y = maze[0].length;//迷宫矩阵的列数
            int i = 0,j = 0;//i,j表示当前移动的位置
            boolean visited[][] = new boolean[x][y];//标志结点是否有访问过
            visited[0][0] = true;
            while(i < x - 1 || j < y - 1){
                MazeNode nextNode = getNext(beginNode,maze,visited);
                if(nextNode.getRow() != beginNode.getRow() || nextNode.getCol() != beginNode.getCol()){
                    stack.push(nextNode);
                    beginNode = nextNode;
                }
                i = nextNode.getRow();
                j = nextNode.getCol();
            }
            return stack;
        }
    
        //寻找当前结点的下一个通路 current表示当前结点
        public  MazeNode getNext(MazeNode current,int[][] maze,boolean visited[][]){
            //表示下一个通路结点
            MazeNode next = null;
            int x = maze.length;//迷宫矩阵的行数
            int y = maze[0].length;//迷宫矩阵的列数
            //当前结点current的上下左右结点中一定有一个结点是isWalk = true的。如果其他位置的三个结点都不是通路,则回到这个结点。
            //current所在位置
            int col = current.getCol();
            int row= current.getRow();
            //栈顶元素
            MazeNode top = stack.peek();
            //判断当前结点的右结点(row,col+1)是否是通路,
            if(col + 1 < y && maze[row][col+1] == 1 && !visited[row][col+1]){
                next = new MazeNode(row,col+1);
                visited[row][col+1]  = true;
            }else{
                //如果右节点不是通路,寻找下结点 
                if(row + 1 < x && maze[row+1][col] == 1 && !visited[row+1][col]){
                    next = new MazeNode(row+1,col);
                    visited[row+1][col]  = true;
                }else{
                    //如果下节点不是通路,寻找左结点 
                    if(col - 1 >= 0 && maze[row][col-1] == 1 && !visited[row][col-1]){
                        next = new MazeNode(row,col-1);
                        visited[row][col-1]  = true;
                    }else{
                        //如果左结点不是通路,寻找上结点
                        if(row - 1 >= 0 && maze[row-1][col] == 1  && !visited[row-1][col]){
                            next = new MazeNode(row-1,col);
                            visited[row-1][col]  = true;
                        }else{
                            //如果上结点都不是通路,就回到栈的栈顶位置。
                            next = top;
                        }
                    }
                }
    
            }
            return next;
        }
    
    }
    import java.util.Stack;
    
    /**
     * 走迷宫算法测试
     * @author liuffei
     * @date 2017年7月10日
     * @description
     */
    public class MazeMain {
    
        public static void main(String[] args) {
    
            int maze[][] = {
                    {1,0,1,0,0,1,0},
                    {1,0,0,0,1,0,1},
                    {1,0,1,1,1,0,0},
                    {1,1,1,0,1,1,1},
                    {0,1,0,0,1,0,1},
                    {0,0,0,0,0,0,1}
            };
    
            MazeRoute mazeRoute = new MazeRoute();
            Stack stack = mazeRoute.findRoute(maze);
            while(!stack.isEmpty()){
                MazeNode node = (MazeNode) stack.pop();
                System.out.println("("+node.getRow()+","+node.getCol()+")");
            }
        }
    
    }

    3.效果展示
    这里写图片描述

    展开全文
  • 根据书中的伪代码实现的迷宫求解,但是并不是最优解,适合刚开始学栈的同学参考 #include #include #include #include #define TURE 1 #define FALSE 0 #define OK 1 #define ERROR 0 #define INFEASINLE -1 #...
  • 数据结构迷宫代码

    2017-12-07 20:45:01
    首先实现一个以链表作存储结构的栈类型,然后编写一个求解迷宫的非递归程序。求得的通路以 三元组(i,j,d)的形式输出,其中(i,j)指示迷宫中的一个位置(行号和列号),d 表示走到下一 位置的方向(对于迷宫中...
  • 数据结构算法 迷宫问题

    千次阅读 2019-03-08 22:09:59
    迷宫问题问题描述: 栈的实现在这篇博客中:https://blog.csdn.net/zj1131190425/article/details/87991662 迷宫是一个矩形区域,有一个出口和入口,迷宫内部包含不能穿越的墙壁和障碍物。 1.用矩阵来描述迷宫。...

    迷宫问题问题描述:

    栈的实现在这篇博客中:https://blog.csdn.net/zj1131190425/article/details/87991662

    迷宫是一个矩形区域,有一个出口和入口,迷宫内部包含不能穿越的墙壁和障碍物。

    1.用矩阵来描述迷宫。入口是(0, 0), 出口是(m,n),现在需要在迷宫中选找一条路径,穿过迷宫。位置(i,j)=1表示有障碍。0表示无障碍。

    思路:

    1.出发点处,定义四个方向的坐标偏移量,搜索等四个方向,直到找到一个可行的方向,按照可行的方向移动到下一个位置,将前一个位置坐标压入栈中(保存路径),且将此位置设置为1(放置障碍物,防止往回退的时候又重新搜索这个方向)

    2. 如果在某个位置没有找到可行的方向,则将当前这个位置设置为1(这个位置不可再回来),从栈顶弹出一个坐标,作为当前坐标(相当于走回头路),继续搜索其他的方向是否可行。

    3. 如此往复

    采用自顶向下设计的方法设计代码:

    (1)输入迷宫

    (2)寻找路径

    (3)输出路径

    #include <iostream>
    #include "E:\back_up\code\c_plus_code\sparseMatrix\external_file\arraystack.h"
    #include <string>
    using namespace std;
    
    // 迷宫
    template<typename T>
    void print_array(T a[][12])
    {
    	for(int i=0; i<12; i++)
    	{
    		for(int j=0; j<12; j++)
    		{
    			cout << a[i][j] << " ";
    		}
    		cout << endl;
    	}
    	cout << endl;
    }
    
    
    class position    // 存储位置坐标 
    {
    	public:
    	int row;
    	int col;
    	position()
    	{
    		row = 0;
    		col = 0;
    	}
    	
    	position(int row, int col)
    	{
    		this->row = row;
    		this->col = col;
    	}
    	
    	void add_offset(position& ps)
    	{
    		row += ps.row;
    		col += ps.col;
    	} 
    }; 
    
    
    
    void find_path(bool map[][12])
    {
    	int map_1[12][12];
    	// 保存map()的一个副本
    	for(int i=0; i<12; i++)
    	{
    		for(int j=0; j<12; j++)
    		{
    			map_1[i][j] = (int)map[i][j];
    		}
    	} 
    	// 寻找迷宫的路径
    	arrayStack<position> path; // 存储路径信息
    
    	// 偏移量
    	position offset[4];
    	
    	// 向右偏移  index=0 
    	offset[0].row = 0;
    	offset[0].col = 1; 
    	// 向下偏移  index=1
    	offset[1].row = 1;
    	offset[1].col = 0;
    	// 向左偏移   index=2
    	offset[2].row = 0;
    	offset[2].col = -1;
    	// 向上偏移   index=3
    	offset[3].row = -1;
    	offset[3].col = 0; 	
    	
    	position current_position(1,1);   // 初始化当前位置
    	int option = 0;  //初始化选的方向,右,下,左,上=(0,1,2,3)
    	int max_otion = 3;   // 方向的选择范围
    	
    	map[1][1] = 1;   // 在(1,1)位置放置障碍 
    	cout << "current position: " << current_position.row << "  " << current_position.col << endl;
    
    	while(current_position.row!=10 || current_position.col!=10)
    	{
    		
    		int r,c;
    		while(option<=max_otion)
    		{
    			r = current_position.row + offset[option].row;
    			c = current_position.col + offset[option].col;
    			if(map[r][c]==0)   // 新的位置可行
    			{
    				break;
    			} 
    		    option++;
    		}
    		
    		if(option<=max_otion)  // 找到了可行的方向
    		{
    			path.push(current_position); 
    			//current_position.add_offset(offset[position]);    // current_position更新 
    			
    			current_position.row = r;    // 移动到新的位置 
    			current_position.col = c;
    			
    			map[r][c] = 1;  // 放置障碍物  避免回退时又选到这个方向 
    			option = 0; 
    		} 
    		
    		else     // 选择的位置走不通 
    		{
    			if(path.empty())
    	        {
            		cout << "The puzzle has no solution" << endl;
            		return;
            	}
            	
            	position next = path.top();
            	path.pop();
            	// 计算返回后的搜索方向:
    			// 按照前面对方向的定义,返回后应该搜索未搜索过的两个方向:
    			// map[currentRow][currentCol] = 1;  // 走不通的位置设置障碍,避免重复搜索 
    			map[current_position.row][current_position.col] = 1;   // 当前的位置是死路 
    			option = 0;
    			current_position = next;   // 浅复制即可 这个类默认的拷贝构造函数 
    		}
    		cout << "(r,c)= " << r << "," << c << endl;
    	}
    	
    	position tmp;
    	while(!path.empty())
    	{
    		// cout << "revise the map" << endl;
    	    tmp = path.top();
    	    path.pop();
    	    map_1[tmp.row][tmp.col] = 2;
    	}
    	
    	// 结果输出 
    	char result[12][12];
    	for(int i=0; i<12; i++)
    	{
    		for(int j=0; j<12; j++)
    		{
    			if(map_1[i][j]==1)
    			{
    				result[i][j]='1';
    			}
    			else if(map_1[i][j]==0)
    			{
    				result[i][j]='0';
    			}
    			else
    			{
    				result[i][j]='*';
    			}
    		}
    	}
    
    	print_array(result); 	
        
    	
    }
    
    
    int main(int argc, char *argv[])
    {
        //int a[12][12];
        bool a[][12] = {
    				     {1,1,1,1,1,1,1,1,1,1,1,1},
    				     {1,0,1,1,1,1,1,0,0,0,0,1},
    				     {1,0,0,0,0,0,1,0,1,0,0,1},
    				     {1,0,0,0,1,0,1,0,0,0,0,1},
    					 {1,0,1,0,1,0,1,0,1,1,0,1},
    					 {1,0,1,0,1,0,1,0,1,0,0,1},
    					 {1,0,1,1,1,0,1,0,1,0,1,1},
    					 {1,0,1,0,0,0,1,0,1,0,1,1},
    					 {1,0,1,0,1,1,1,0,1,0,0,1},
    					 {1,1,0,0,0,0,0,0,1,0,0,1},
    					 {1,0,0,0,0,1,1,1,1,0,0,1},
    			 		 {1,1,1,1,1,1,1,1,1,1,1,1} 
    			        };
        //print_array(a);
        find_path(a);
        return 0;
    }
    
    

    运行结果:

    迷宫问题最短路径

    可以使用队列来实现寻找最短路径的操作

    首先介绍C++ 实现队列:关于队列的实现参考博客: https://blog.csdn.net/zj1131190425/article/details/88090905,下面的队列是对https://blog.csdn.net/zj1131190425/article/details/88090905中队列的改进,主要是改经了ensureCapacity()函数,因为原来的队列中ensureCapacity()函数有点小的bug.

    定义一个队列的基类,queueABC

    queueABC.h文件

    #ifndef QUEUE_ABC_H
    #define QUEUE_ABC_H
    
    using namespace std;
    // 定义抽象类
    template<typename T>
    class queueABC
    {
    	public:
    	// virtual ~queue();
    	virtual bool empty() const=0;  // 纯虚函数 只读
    	virtual int size() const=0;    // 返回队列中元素的个数   
    	virtual T& front() = 0;        // 返回队首元素
    	virtual T& back() = 0;         // 返回队尾元素
    	virtual void pop() = 0;        // 删除队首的元素
    	virtual void push(T x) = 0;    // 队尾插入元素 
    };
    #endif
    

    queue.h

    #ifndef QUEUE_H
    #define QUEUE_H
    
    #include <iostream>
    #include <algorithm>
    #include "E:\back_up\code\c_plus_code\dequeue\external_file\queueABC.h"   // 包含ABC文件 
    #include "E:\back_up\code\c_plus_code\dequeue\external_file\queueemptyEx.h"   // 包含异常类文件 
    using namespace std;
    
    template<typename T>
    class queue : public queueABC<T>
    {
    	private:
    	int arrayLength;  // 数组的长度
    	int queueSize;   // 队列中元素的个数
    	int queueFront;   // 队首元素所在的位置
    	int queueBack;    // 队尾元素所在的位置
    	T* element; 
    	void ensureArrayLength();   // 进行数组扩容 
    	
    	public:
    	queue(int arrayLength=10);    // 构造函数 
    	~queue();                     // 析构函数 
    	queue(const queue& q);        // 拷贝构造函数 
    	
    	// ADT 
    	bool empty() const;
    	int size() const;
    	T& front();
    	T& back();
    	void pop();
    	void push(T x);
    	void display_queue() const;   // 打印输出队列中的元素 
    	
    };
    
    template<typename T>
    queue<T>::queue(int arrayLength)
    {
    		this->arrayLength = arrayLength;
    		this->queueSize = 0;
    		this->queueFront = 0;
    		this->queueBack = 0;
    		element = new T[arrayLength];
    }
    
    template<typename T>
    queue<T>::~queue()
    {
    	delete [] element;
    } 
    
    template<typename T>
    queue<T>::queue(const queue& q)
    {
    	arrayLength = q.arrayLength;
    	queueSize = q.queueSize;
    	queueFront = q.queueFront;
    	queueBack = q.queueBack;
    	element = new T[arrayLength];
    	for(int i=0; i<queueSize; i++)
    	{
    		element[i] = q.element[i];
    	}
    } 
    
    template<typename T>
    bool queue<T>::empty() const
    {
    	return queueSize==0;
    } 
    
    template<typename T>
    int queue<T>::size() const
    {
    	return queueSize;
    }
    
    template<typename T>
    T& queue<T>::front()
    {
    	return element[(queueFront+1)%arrayLength];  // queueFront是队首元素的前一个位置,+1是表示队首元素的位置 
    }
    
    template<typename T>
    T& queue<T>::back()
    {
    	return element[queueBack%arrayLength];    // queueback队尾元素的位置 
    }
    
    /*
    template<typename T>
    void queue<T>::ensureArrayLength()
    {
    	// 如果需要,增加数组长度 
    	if((queueBack+1)%arrayLength==queueFront)   // 环形的数组 
    	{
    		T* old;
    		old = element;
    		//delete element;
    		// arrayLength = arrayLength*2;   // 增加分配的内存长度 
    		element = new T[2*arrayLength]; 
    		// 环形数组重新布局
    		// 先将数组复制过来
    		//更新关于数组复制
    		int index_tmp;
    	    for(int i=0; i<queueSize; i++)
    	    {
        		index_tmp = (queueFront+1+i)%arrayLength;
        		element[index_tmp] = old[index_tmp];
        	}
    		 
    		delete old;
    		// 重新布局  // 分为三种情况:1.queuefront=0; queuefront==arrayLength-1; else;
    		int pre_start = queueFront%arrayLength;  // 队列首元素的前一个位置 
    		if(pre_start==0)
    		{
    			// 移动所有的数组元素 
    			for(int i=0; i<queueSize; i++)
    			{
    				element[2*arrayLength-1-i] = element[(queueBack%arrayLength)-i];
    			} 
    			queueFront = queueFront + arrayLength;
    			queueBack = queueBack + arrayLength;
    		} 
    		else if(pre_start==arrayLength-1)   // arrayLength还是原来的值 
    		{
    			// 不用移动数组元素,之更改front 
    			queueFront = queueFront + arrayLength; 
    		}
    		else
    		{
    			// 移动第二段的元素:
    			int element_to_move = arrayLength-1-(queueFront%arrayLength);  // 计算第二段需要移动的元素的数量 
    			for(int i=0; i<element_to_move; i++)
    			{
    				element[2*arrayLength-1-i] = element[queueBack%arrayLength-i];
    			} 
    			queueFront = queueFront + arrayLength;
    		}
    		arrayLength = arrayLength*2;   // 更新arrayLength 		 
    	}
    	// 添加一个动态减少内存的函数 
    }
    */
    
    template<typename T>
    void queue<T>::ensureArrayLength()
    {
    	if((queueBack+1)%arrayLength==queueFront)   // 环形的数组 
    	{
    		T* new_element = new T[2*arrayLength];
    		int start = (queueFront+1)%arrayLength;
    		if(start<2)   // 没有形成环
    		{
    			copy(element+start, element+start+arrayLength-1, new_element);    // 复制操作 
    		} 
    		else   // 形成环
    		{
    			copy(element+start, element+arrayLength, new_element);
    			copy(element, element+queueBack+1, new_element+arrayLength-start);
    		} 
    		queueFront = 2*arrayLength-1;
    		queueBack = arrayLength-2;
    		arrayLength *= 2;
    		delete[] element;
    		element = new_element;
    	}
    }
    
    // push()操作:
    template<typename T>
    void queue<T>::push(T x)
    {
    	ensureArrayLength();     // 先保证数组长度满足条件
    	queueSize++;
    	//queueBack = (queueBack+1)%arrayLength;
    	//element[queueBack] = x;	 
    	queueBack++;
    	element[queueBack%arrayLength] = x;
    } 
    
    //pop()操作 
    template<typename T>
    void queue<T>::pop()
    {
    	if(empty())
            throw queueEmptyException(0); 
    	queueFront++;
    	queueSize--;
    	// element[queueFront].~T;
    } 
    
    template<typename T>
    void queue<T>::display_queue() const
    {
    	//int tmp = queueFront;
    	// int start_pos = (tmp+1)%arrayLength;
    	if(empty())
    	{
    		cout << "The queue is empty!" << endl;
    		return;
    	}
    	
    	for(int i=0; i<queueSize; i++)
    	{
    		cout << element[(queueFront+1+i)%arrayLength] << " ";
    	}
    	cout << endl;
    }
    
    #endif 

    自定义的异常类:

    queueemptyException:

    // 自定义异常类
    #ifndef QUEUE_EMPTY_EXCEPTION
    #define QUEUE_EMPTY_EXCEPTION
    #include <stdexcept>
    #include <iostream>
    using namespace std;
    
    class queueEmptyException : public runtime_error
    {
    	private:
    	int queueSize;
    	
    	public:
    	queueEmptyException(int queueSize) : runtime_error("The queue empty!")
    	{
    		this->queueSize = queueSize;
    	}
    	
    	void display_error_info()
    	{
    		cout << "The queue size is " << queueSize << endl;
    	}
    };
    #endif

    寻找最短路径的算法思路:

    从上面的迷宫中,找一条从入口到出口的最短路径,要有两个过程:

    1. 一个是距离标记过程

    2. 另一个是路径标记过程

    在距离标记过程中,把能从入口到达的相邻位置标记为1,然后把从编号为1可到达的相邻位置标记为2(表示与入口相距为2),直到到达出口或者没有可标记的相邻位置为止。

    在路径标记过程中,从出口开始,首先移动到比出口的编号小1的位置,再从当前位置移动到比其编号小1的位置上,直到到达起点为止,这便是最短的路径

    3.按照上述思路编写代码实现:

    main.cpp

    #include <iostream>
    #include "E:\back_up\code\c_plus_code\dequeue\external_file\queue.h"
    using namespace std;
    
    // 迷宫
    template<typename T>
    void print_array(T **a, int size)
    {
    	for(int i=0; i<size; i++)
    	{
    		for(int j=0; j<size; j++)
    		{
    			cout << a[i][j] << " ";
    		}
    		cout << endl;
    	}
    	cout << endl;
    }
    
    
    class position    // 存储位置坐标 
    {
    	public:
    	int row;
    	int col;
    	position()
    	{
    		row = 0;
    		col = 0;
    	}
    	
    	position(int row, int col)
    	{
    		this->row = row;
    		this->col = col;
    	}
    	
    	/*
    	void add_offset(position& ps)
    	{
    		row += ps.row;
    		col += ps.col;
    	}
    	*/
    	 
    }; 
    
    
    void findPath(int** map, int mapSize=10)
    {
    	// 这里默认起始点为(0,0),终点为(9,9)
    	
    	// 给地图添加围墙:
    	int** new_map = new int*[mapSize+2];
    	for(int i=0; i<mapSize+2; i++)
    	{
    		new_map[i] = new int[mapSize+2];
    	} 
    	for(int i=0; i<mapSize+2; i++)
    	{
    		for(int j=0; j<mapSize+2; j++)
    		{	
    			if(i==0 || i==mapSize+2-1)
    			{
    				new_map[i][j] = 1;  // 增加行围墙 
    			}
    			else if(j==0 || j==mapSize+2-1)   //增加列围墙 
    			{
    				new_map[i][j] = 1;
    			}
    			else  // 保存地图 
    			{
    				new_map[i][j] = map[i-1][j-1]; 
    			} 
    			
    		}
    	}
    	
    	// print_array(map, mapSize);
    	cout << "原始地图: " << endl;
    	print_array(new_map, mapSize+2);
    	
    	// 初始化偏移量
    	position offset[4];
    	// 向右偏移  index=0 
    	offset[0].row = 0;
    	offset[0].col = 1; 
    	// 向下偏移  index=1
    	offset[1].row = 1;
    	offset[1].col = 0;
    	// 向左偏移   index=2
    	offset[2].row = 0;
    	offset[2].col = -1;
    	// 向上偏移   index=3
    	offset[3].row = -1;
    	offset[3].col = 0; 	
    	
    	position current_position(1,1);   // 初始化当前位置
    	position end_position(10,10);
    	new_map[current_position.row][current_position.col] = 2;  // 这里距离标记从2开始,实际距离等于标号-2
    	int direction_number = 4;   // 一个方格相邻位置的个数 
    	position neighbor;
    	queue<position> q;    // 队列,用于存放标记的位置 
    	while(true)
    	{
    		// 给相邻位置做标记
    		for(int i=0; i<direction_number; i++)
    		{
    			neighbor.row = current_position.row + offset[i].row;
    			neighbor.col = current_position.col + offset[i].col;
    			if(new_map[neighbor.row][neighbor.col]==0)  // 可标记的位置
    			{
    				new_map[neighbor.row][neighbor.col] = new_map[current_position.row][current_position.col]+1; // 标记 
    				if(neighbor.row==end_position.row && neighbor.col==end_position.col)
    				{
    					break;   // 标记完成 
    				} 
    				q.push(neighbor); 
    			} 
    		}
    		if(neighbor.row==end_position.row && neighbor.col==end_position.col)
    		{
    			break;   // 到达 
    		}
    		
    		if(q.empty())    // 迷宫无解; 
    		{
    			cout << "The puzzle has no solution" << endl;
    			return;
    		}
    		
    		current_position = q.front();
    		q.pop(); 
    	}
    	//cout << "标记完的矩阵: " << endl; 
    	//print_array(new_map, 12); 
    	
    	// 构造路径;
    	int pathLength = new_map[end_position.row][end_position.col]-2;  // 路径的长短 
        // position* path = new position[pathLength];
    	
    	queue<position> q_path;   // 存储路径 
    	current_position =  end_position;   // 从终点回溯
    	for(int i=pathLength-1; i>=0; i--)
    	{
    		// path[i] = current_position;   
    		q_path.push(current_position);    // 当前的位置放入队列中 
    		for(int j=0; j<direction_number; j++)
    		{
    			neighbor.row = current_position.row + offset[j].row;
    			neighbor.col = current_position.col + offset[j].col;
    			if(new_map[neighbor.row][neighbor.col] == i+2)
    			{
    				break;
    			}
    		} 
    		//测试 
    		// cout << "current position: " << current_position.row << ',' << current_position.col << endl;
    		current_position = neighbor;	
    	} 
    	
    	/*    测试代码 
    	position tmp; 
    	while(!q_path.empty())
    	{
    		tmp = q_path.front();
    		cout << "path: " << tmp.row << "," << tmp.col << endl;
    		q_path.pop();
    	}
    	*/
    	
    	/*   测试代码 
    	for(int i=0; i<pathLength; i++)
    	{
    		cout << "path: " << path[i].row << "," << path[i].row << endl;
    	}
    	*/
    	
    	
    	
    	// 输出结果 
    	char** result = new char*[mapSize+2];    // 创建一个新的矩阵保存可视化结果 
    	for(int i=0; i<mapSize+2; i++)
    	{
    		result[i] = new char[mapSize+2];
    	}
    	// 初始化:
    	position tmp;
    	while(!q_path.empty())
    	{
    		tmp = q_path.front();
    		result[tmp.row][tmp.col] = '*';
    		q_path.pop();
    	} 
    	
    	for(int i=0; i<mapSize+2; i++)
    	{
    		for(int j=0; j<mapSize+2; j++)
    		{
    			if(result[i][j] != '*' && new_map[i][j]==1)
    			{
    				result[i][j] = '1';
    			}
    			if(result[i][j] != '*' && (new_map[i][j]==0 || new_map[i][j]>1))
    			{
    				result[i][j] = '0';
    			}
    		}
    	}	
    	
    	// 输出迷宫路径
    	cout << "最短路径: " << pathLength << endl; 
    	cout << "迷宫路径如下所示: " << endl;
    	print_array(result, mapSize+2); 
    	
    } 
    
    
    
    int main(int argc, char *argv[])
    {	
        int map_size = 10;
        int input_map[10][10] = {
       	                   {0,1,1,1,1,1,0,0,0,0},
       	                   {0,0,0,0,0,1,0,1,0,0},
    					   {0,0,0,1,0,1,0,0,0,0},
    					   {0,1,0,1,0,1,0,1,1,0},
    					   {0,1,0,1,0,1,0,0,0,0},
    					   {0,1,0,0,0,1,0,1,0,1},
    					   {0,1,0,0,0,1,0,1,0,1},
    					   {1,0,0,0,0,0,0,1,0,0},
    					   {0,0,0,0,1,1,1,1,0,0} 
                          };
        // 数据转换 
    	int** map_in = new int*[map_size];
    	for(int i=0; i<map_size; i++)
    	{
    		map_in[i] = new int[map_size];
    	}
    	for(int i=0; i<map_size; i++)
    	{
    		for(int j=0; j<map_size; j++)
    		{
    			map_in[i][j] = input_map[i][j];
    		}
    	}
    	
    	// 将原始地图转换为指针的形式
    	findPath(map_in, map_size);    
    	return 0;
    }
    

    算法的运行结果如下图所示:

    ---------------------------------------------------end----------------------------------------------------------

    展开全文
  • 数据结构课程设计之C++编写的迷宫问题路径求解程序,使用的是栈方法,即将路径上每一步存在栈中,迷宫文件格式见程序提示,压缩包内已经给出了三个测试用的迷宫地图可用来测试,支持分步显示查找路径过程功能,当给...
  • 关于迷宫,承载着我们童年中的点滴记忆。当然,那时候总有些迷宫册子,每本还有专门的主题(奥特曼,葫芦娃,铠甲勇士什么的= =)...但是,在计算机行业领域中,我们更看重数据,以及对数据的运算和处理。所以 解决迷宫

        关于迷宫,承载着我们童年中的点滴记忆。当然,那时候总有些迷宫册子,每本还有专门的主题(奥特曼,葫芦娃,铠甲勇士什么的= =)。而且不得不说,真是干一行爱一行,这些出册子的人,把迷宫这个游戏可是上升到了一个高度。就比如说什么“碰见怪兽了要折返”什么的。

        以上基于我们的童年,更基于那些“伟大的”迷宫设计设计师们。但是,在计算机行业领域中,我们更看重数据,以及对数据的运算和处理。所以 解决迷宫问题 就成了初学者对计算机编程技术及思想的一次质的飞跃。

        好,废话不多说,接下来,我将从对迷宫算法的分析,数据结构的选择,及程序的实现进行简略描述。


        1)迷宫算法的分析:

        在计算机中,为了着重数据操作,我忽略掉了类似立交桥般复杂的线路,以及小怪兽的设定等。

        如图左上角空白(#为边界,空白即指无字符的地方)为起点,右下角为终点。此迷宫中最需要我们想到的该是有岔道,还有圈。

        

        也就是说程序应当有排除岔道,还有排除圈的能力。对于排除岔道,只要判断当前位置对于行迷宫者来说是否为#即可,而对于圈,我们可以用一个mark数组来标记此位置是否走过,每当向下一个位置走时就同时判断是否为#和此位置是否走过即可(这两个判断在下文直接简称为“通路成立判断”)。

        以上仅解决了两个小问题,而更重要的是:行迷宫者到底如何走,是让它一直向上走,还是一直向右走,还是转着圈走。当我们在想它如何走时,方法就出现了。我们可以记录当前坐标值,然后对周围四个方向,即上,下,左,右依次进行“通路成立判断”,如果成立,按成立的那个方向移动一格,并再次让程序进行周围四个方向,即上,下,左,右依次进行“通路成立判断”。当四个方向的“通路成立判断”都不成立,那么就知道此路不通,接着让行迷宫者按原路返回,并继续进行没有判断完的方向(例如,某个位置向左可以走,但移动后发现四个方向的“通路成立判断”都不成立,那么此时倒退回去,并接着进行右的“通路成立判断”(因为判断顺序为上,下,左,右))就这样,让程序不断地做此种循环,直到当前坐标值等于终点坐标值。

        但是,我们的目的是为了让程序求显示出求解过程,以上只是让行迷宫者走到了终点,而并没有记录他的行迹。接下来,我对存储路径的数据结构的选择进行描述。


        2)数据结构的选择

     

        栈是后进先出的线性数据结构,当每走一格时,就对上一格的坐标和向下一格要走的方向进行记录(即遵从:当前坐标+方向=下一格要走的坐标=路径描述)。并规定每当遇到死路,即四个方向的“通路成立判断”都不成立时,从栈中取出栈顶元素(因为栈顶恰好是上一步的路径描述)。就这样到当前坐标值等于终点坐标值时,及循环停止时,栈中的所有元素自下而上就是对路径的全部描述。

        紧接着,可以根据算法与数据结构编出程序来,下面就是程序的实现。


        3)程序的实现

    #include<iostream>
    #include<cstdlib>
    #define Max_Size 100
    
    using namespace std;
    
    enum Direcation
    {
    	Up = 1,
    	Down = 2,
    	Left = 3,
    	Right = 4
    };
    typedef struct
    {
    	int x, y;
    }Coordinate;
    typedef struct
    {
    	Coordinate coord;
    	Direcation direcation;
    }Node;
    class Stack
    {
    public:
    	Stack();
    	bool IsEmpty() const;
    	bool IsTopful() const;
    	bool Push(Node Pushed);
    	bool Pop();
    	const Node& GetTop() const;
    	void Output() const;
    private:
    	Node stack[Max_Size];
    	unsigned int top;
    };
    
    void Check(const bool MAZE[][10], bool MARK[][10], Stack &wizard, Coordinate coord);
    void OutputMaze(const bool MAZE[][10]);
    
    const Coordinate Origin = { 1, 1 }, Terminal = { 8, 8 };
    
    int main()
    {
    	Stack wizard;
    	Coordinate coord = Origin;
    	bool MAZE[10][10]={
    		{1, 1, 1, 1, 1, 1, 1, 1, 1, 1},
    		{1, 0, 0, 0, 0, 0, 1, 1, 0, 1},
    		{1, 0, 1, 0, 1, 0, 0, 1, 0, 1},
    		{1, 0, 1, 0, 0, 0, 1, 0, 0, 1},
    		{1, 0, 1, 1, 1, 0, 0, 0, 1, 1},
    		{1, 0, 1, 0, 1, 1, 1, 1, 1, 1},
    		{1, 0, 1, 0, 0, 0, 0, 0, 0, 1},
    		{1, 0, 1, 0, 1, 0, 1, 1, 0, 1},
    		{1, 0, 0, 0, 1, 0, 0, 1, 0, 1},
    		{1, 1, 1, 1, 1, 1, 1, 1, 1, 1}};
    	bool MARK[10][10] = {
    		{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
    		{ 0, 1, 1, 1, 1, 1, 1, 1, 1, 0 },
    		{ 0, 1, 1, 1, 1, 1, 1, 1, 1, 0 },
    		{ 0, 1, 1, 1, 1, 1, 1, 1, 1, 0 },
    		{ 0, 1, 1, 1, 1, 1, 1, 1, 1, 0 },
    		{ 0, 1, 1, 1, 1, 1, 1, 1, 1, 0 },
    		{ 0, 1, 1, 1, 1, 1, 1, 1, 1, 0 },
    		{ 0, 1, 1, 1, 1, 1, 1, 1, 1, 0 },
    		{ 0, 1, 1, 1, 1, 1, 1, 1, 1, 0 },
    		{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, };
    	Check(MAZE, MARK, wizard, coord);
    	OutputMaze(MAZE);
    	wizard.Output();
    	cout << "9,9   !\n\n";
    	system("pause");
    	return 0;
    }
    
    void Check(const bool MAZE[][10], bool MARK[][10], Stack &wizard, Coordinate coord)
    {
    	Node now;
    	MARK[coord.x][coord.y] = false;//mark
    
    	if (MARK[coord.x - 1][coord.y] && MAZE[coord.x - 1][coord.y] == 0)//up
    	{
    		if (coord.x == Terminal.x&&coord.y == Terminal.y) return;//1.check true or false
    		now.coord = coord; now.direcation = Up;//2.unload
    		wizard.Push(now);//3.push to stack;
    		coord.x--;//4.change moveable coordinate
    		Check(MAZE, MARK, wizard, coord);//5.provide the coordinate at present
    	}
    	else if (MARK[coord.x][coord.y - 1] && MAZE[coord.x][coord.y - 1] == 0)//left
    	{
    		if (coord.x == Terminal.x&&coord.y == Terminal.y) return;
    		now.coord = coord; now.direcation = Left;
    		wizard.Push(now);
    		coord.y--;
    		Check(MAZE, MARK, wizard, coord);
    	}
    	else if (MARK[coord.x][coord.y + 1] && MAZE[coord.x][coord.y + 1] == 0)//right
    	{
    		if (coord.x == Terminal.x&&coord.y == Terminal.y) return;
    		now.coord = coord; now.direcation = Right;
    		wizard.Push(now);
    		coord.y++;
    		Check(MAZE, MARK, wizard, coord);
    	}
    	else if (MARK[coord.x + 1][coord.y] && MAZE[coord.x + 1][coord.y] == 0)//down
    	{
    		if (coord.x == Terminal.x&&coord.y == Terminal.y) return;
    		now.coord = coord; now.direcation = Down;
    		wizard.Push(now);
    		coord.x++;
    		Check(MAZE, MARK, wizard, coord);
    	}
    	else
    	{
    		if (coord.x == Terminal.x&&coord.y == Terminal.y) return;//1.check true or false
    		coord = wizard.GetTop().coord;//2.change moveable coordinate
    		wizard.Pop();//3.delete
    		Check(MAZE, MARK, wizard, coord);//4.provide the coordinate at present
    	}
    	return;
    }
    void OutputMaze(const bool MAZE[][10])
    {
    	for (int inset = 0; inset < 10; inset++)
    	{
    		for (int inset1 = 0; inset1 < 10; inset1++)
    		{
    			if (MAZE[inset][inset1])
    				cout << "# ";
    			else
    				cout << "  ";
    		}
    		cout << endl;
    	}
    	cout << endl;
    }
    
    Stack::Stack()
    {
    	top = 0;
    }
    bool Stack::IsEmpty() const
    {
    	return (top == 0);
    }
    bool Stack::IsTopful() const
    {
    	return (top == Max_Size + 1);
    }
    bool Stack::Push(Node Pushed)
    {
    	if (IsTopful())
    		return false;
    	else
    	{
    		stack[top] = Pushed;
    		top++;
    		return true;
    	}
    }
    bool Stack::Pop()
    {
    	if (IsEmpty())
    		return false;
    	else
    	{
    		top--;
    		return true;
    	}
    }
    const Node& Stack::GetTop() const
    {
    	return stack[top - 1];
    }
    void Stack::Output() const
    {
    	for (unsigned int inset = 0; inset < top; inset++)
    	{
    		cout << stack[inset].coord.x + 1 << ',' << stack[inset].coord.y + 1 << "   ";
    		switch (stack[inset].direcation)
    		{
    		case Up:cout << "Up"; break;
    		case Down:cout << "Down"; break;
    		case Left:cout << "Left"; break;
    		case Right:cout << "Right"; break;
    		default:cout << "Unknow";
    		}
    		cout << endl;
    	}
    	cout << endl;
    	return;
    }
    以及程序的输出:




    by WIzaRD_ssc

    展开全文
  • 迷宫问题是一个非常经典的算法问题 设计算法 //1.map 表示地图 //2.i,j表示地图的哪个位置开始出发(1,1) //3.如果小球能到map【6][5]位置,则说明通路找到 //4.约定:当map[i][j]为0表示该点没有走过当为1时...
  • 数据结构算法分析》课程设计——迷宫问题 - 刷子zz - 博客园 一、问题描述 问题中迷宫可用方阵[m,n]表示,0表示能通过,1表示不能通过。若要从从左上角[1,1]进入迷宫,设计算法,寻求一条从右下角 [m,n] ...
  • #资源达人分享计划#
  • . 摘要 本文详细介绍了迷宫问题的设计与实现 该程序具有迷宫的...迷宫逃离路线的产生及打印本系统采用了栈的结构有利于数据的存储与输出 在设计该程序时采用了挨个试探的方法 简单易懂 程序通过调试运行 实现了 最初的
  • 数据结构课程设计迷宫算法的实现_java.doc还剩24页未读,继续阅读下载文档到电脑,马上远离加班熬夜!亲,喜欢就下载吧,价低环保!内容要点:路5. 点击“Reset”可复位,即显示出原先的迷宫。6. 进度条可控制搜寻...
  • 设计非递归算法,根据入口和出口位置将给定迷宫中的全部可行路线输出,并标记出其中的最短路径; int mg[10][10]={ {1,1,1,1,1,1,1,1,1,1}, {1,0,0,1,0,0,0,1,0,1}, {1,0,0,1,0,0,0,1,0,1}, {1,0,0,0,0,1,1,0,0,...
  • 在学习数据结构中自己实现的迷宫游戏。这个代码中有迷宫生成(迷宫比较不错),然后对生成的迷宫用递归算法寻找路径。在迷宫设计以及递归学习是个不错的选择。
  • 迷宫课程设计,有图形化界面,可以单步演示、整体演示、自由设定迷宫大小,使用java语言,封装良好,易于修改。
  • 迷宫问题 思想: 用递归解决迷宫问题 1:先创建迷宫,用二维数组模拟迷宫地图 2:制定一个策略:例如先下→右→上→左等等 3:设置一些标识信息:例如:0表示还没有走过;1表示的是墙走不通;2表示这个点可以通;3...
  • 迷宫算法 数据结构

    2014-06-20 12:00:28
    完整的迷宫代码,用C++数据结构编写,适合新手看,可以用于简单的迷宫实现,未封装
  • 文章目录递归调用机制简单的递归使用递归能解决的问题和规则递归-迷宫问题思路分析:代码如下: 递归调用机制 简单地说:递归就是方法自己调用自己,每次调用时传入不同的变量,递归有助于编程者解决复杂的问题,...
  • 迷宫求解问题(数据结构课设)

    千次阅读 2021-01-15 15:10:53
    迷宫求解问题(课设) 一、程序设计题目 二、算法所需的数据结构 三、算法设计思想(流程图或者思维导图,并标注各模块对应的函数说明) 1、整体思路 2、DFS 3、BFS 4、实验大致的思维导图 四、代码 五、运行结果 六...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 10,955
精华内容 4,382
关键字:

数据结构迷宫算法

数据结构 订阅