这是我写的一个九宫格问题,写得比较水，太复杂的就搞不好，希望看着能提出优化建议！！！

  1. import java.util.LinkedList;
  2. import java.util.Queue;
  3. import java.util.Scanner;
  4. import javax.management.Query;
  5. public class java_debug {
  6. static int queue_node_num=0;//node number
  7. static int son_node=0;//子节点位置
  8. static int closed_node_first=0;//close队列首节点
  9. int node_now=0;//中间变量
  10. static boolean node_exist = false;
  11. static node[] node_name=new node[10000];
  12. static int[][]   initial_element=new int[][]{{0,0,0},{0,0,0},{0,0,0}};
  13. //队列
  14. static Queue<Integer> open= new LinkedList<Integer>();
  15. static Queue<Integer> closed= new LinkedList<Integer>();
  16. static int[][]  target_element= new  int[][]{{1,2,3},{4,5,6},{7,8,0}};
  17. private static  void  input_function(int[][]  target_input)
  18. {
  19. System.out.println("please input the node!");
  20. for(int j=0;j<=2;j++)
  21. for(int i=0;i<=2;i++){
  22. Scanner   target_node=new Scanner(System.in);
  23. target_input[j][i]=target_node.nextInt();
  24. }
  25. for(int i=0;i<=2;i++)
  26. for(int ele_node:target_input[i])
  27. {
  28. if(ele_node>9&&ele_node<0)   {System.out.println("the input is error!");
  29. }}
  30. }
  31. //比较函数
  32. private static boolean compare_function(int[][] target_node,int[][] son_target)
  33. {   for(int i=0;i<=2;i++)
  34. for(int j=0;j<=2;j++)
  35. {  if(target_node[i][j]!=son_target[i][j])
  36. return false;
  37. }
  38. return true;
  39. }
  40. //初始化该节点
  41. private static void initialize_node(node[] node_name,int queue_node_num,int father_node_num)
  42. {   node_name[queue_node_num+1].node_name=queue_node_num+1;
  43. node_name[queue_node_num+1].father_name=father_node_num;
  44. node_name[queue_node_num+1].location=location(node_name[queue_node_num+1]);
  45. open.offer(node_name[queue_node_num+1].node_name);
  46. }
  47. //0的位置
  48. private  static int location(node node_name)
  49. {int location_coord=0;
  50. for(int j=0;j<=2;j++)
  51. for(int i=0;i<=2;i++)
  52. {
  53. if(node_name.node_element[j][i]==0)
  54. {location_coord=(j*3+i);
  55. return location_coord;}
  56. }
  57. return 9;
  58. }
  59. //该节点是否已经存在
  60. private static boolean compare_old_node(node[] node_name2,int queue_node_num)
  61. {
  62. while(closed.peek()!=null)
  63. {int i=0;i++;
  64. if(i==0) { closed_node_first=closed.poll(); son_node=closed_node_first;}
  65. else son_node=closed.poll();
  66. if((son_node==closed_node_first)&&(i!=0)) {closed.offer(son_node);return false;}
  67. if(node_name2[queue_node_num+1].location==node_name2[son_node].location)
  68. node_exist=compare_function(node_name2[queue_node_num+1].node_element,node_name2[son_node].node_element);
  69. if(node_exist==true)
  70. return true;
  71. closed.offer(son_node);
  72. }
  73. return false;
  74. }
  75. //x,y代表初始坐标  z,w  代表目标坐标  row代表在行上移动还是在列上移动
  76. private   static void  initial_son_node(node[] node_name,int queue_node_num,int father_node_num,int x,int y, int z,int w,boolean row)
  77. {    node_name[queue_node_num+1]=new node( initial_element,queue_node_num+1,father_node_num,0);
  78. node_name[queue_node_num+1].node_element[z][w]=node_name[father_node_num].node_element[x][y];
  79. node_name[queue_node_num+1].node_element[x][y]= node_name[father_node_num].node_element[z][w];
  80. node_name[queue_node_num+1].node_name=queue_node_num+1;
  81. node_name[queue_node_num+1].father_name=father_node_num;
  82. for(int j=0;j<=2;j++)
  83. for(int i=0;i<=2;i++)
  84. {if(row==true) {
  85. if(j==x&&(i==y||i==w))
  86. {}
  87. else
  88. node_name[queue_node_num+1].node_element[j][i]=node_name[father_node_num].node_element[j][i];}
  89. else
  90. {if(i==y&&(j==x||j==z))
  91. {}
  92. else
  93. node_name[queue_node_num+1].node_element[j][i]=node_name[father_node_num].node_element[j][i];
  94. }}
  95. }
  96. private static  int search(node[] node_name,int queue_node_num,int father_name_num,int x,int y,int z,int w,boolean row)
  97. {  boolean   closed_exist_state=true;
  98. initial_son_node(node_name,queue_node_num,father_name_num,x,y,z,w,row);//从父节点得到子节点
  99. closed_exist_state=compare_old_node(node_name,queue_node_num);//该节点是否存在closed节点中
  100. if(closed_exist_state==false)
  101. {
  102. initialize_node(node_name,queue_node_num,father_name_num);//对该类就行初始化
  103. closed_exist_state=compare_function(node_name[queue_node_num].node_element,target_element);
  104. if(closed_exist_state)  System.out.println("the result has find");//如果与目标节点相同则输出！
  105. queue_node_num++;}
  106. return queue_node_num;
  107. }
  108. @SuppressWarnings("null")
  109. public static void main(String[] args) throws Exception
  110. {
  111. int[][]   begin_element=new  int[][]{{1,2,3},{0,4,5},{7,8,6}};
  112. int j=0;
  113. int father_node_num=0;
  114. //初始化首节点
  115. node_name[0]=new node(begin_element,0,0,0);
  116. open.offer(node_name[0].node_name);//压入节点名称
  117. node_name[0].location=location( node_name[0]);
  118. 获取子节点
  119. while(open.peek()!=null) { //循环
  120. j++;
  121. if(j>500)System.out.println("the program is not find the result!!");
  122. System.out.println(j);
  123. father_node_num=open.poll();
  124. if(compare_function(target_element,node_name[father_node_num].node_element))
  125. { System.out.println("success!");
  126. while(node_name[father_node_num].node_name!=0)
  127. {
  128. for(int i=0;i<=2;i++)
  129. {for(int j1=0;j1<=2;j1++)
  130. System.out.print(node_name[father_node_num].node_element[i][j1]+" ");
  131. System.out.println( );
  132. }
  133. System.out.println(node_name[father_node_num].node_name);
  134. father_node_num=node_name[father_node_num].father_name;
  135. }
  136. break;}
  137. //queue_node_num=father_node_num;
  138. closed.offer( father_node_num);//压入closed队列
  139. son_node=node_name[father_node_num].location;
  140. switch(son_node){
  141. case 0:
  142. /* node_name[queue_node_num+1].node_element[0][1]=node_name[father_node_num].node_element[0][0];
  143. node_name[queue_node_num+1].node_element[0][0]= node_name[father_node_num].node_element[0][1];
  144. node_name[queue_node_num+1].node_name=queue_node_num+1;
  145. node_name[queue_node_num+1].father_name=father_node_num;
  146. for(int j=0;j<=2;j++)
  147. for(int i=0;i<=2;i++)
  148. {    if(j==0&&(i==0||i==1))
  149. {}
  150. else
  151. node_name[queue_node_num+1].node_element[j][i]=node_name[queue_node_num].node_element[j][i];
  152. }*/
  153. queue_node_num= search(node_name,queue_node_num,father_node_num,0,0,0,1,true);
  154. queue_node_num= search(node_name,queue_node_num,father_node_num,0,0,1,0,false);
  155. break;
  156. case 1:
  157. queue_node_num= search(node_name,queue_node_num,father_node_num,0,1,0,0,true);
  158. queue_node_num=search(node_name,queue_node_num,father_node_num,0,1,0,2,true);
  159. queue_node_num=search(node_name,queue_node_num,father_node_num,0,1,1,1,false);
  160. break;
  161. case 2:
  162. queue_node_num=search(node_name,queue_node_num,father_node_num,0,2,0,1,true);
  163. queue_node_num=search(node_name,queue_node_num,father_node_num,0,2,1,2,false);
  164. break;
  165. case 3:
  166. queue_node_num=search(node_name,queue_node_num,father_node_num,1,0,0,0,false);
  167. queue_node_num=search(node_name,queue_node_num,father_node_num,1,0,1,1,true);
  168. queue_node_num=search(node_name,queue_node_num,father_node_num,1,0,2,0,false);
  169. break;
  170. case 4:
  171. queue_node_num= search(node_name,queue_node_num,father_node_num,1,1,0,1,false);
  172. queue_node_num=search(node_name,queue_node_num,father_node_num,1,1,1,0,true);
  173. queue_node_num=search(node_name,queue_node_num,father_node_num,1,1,1,2,true);
  174. queue_node_num=search(node_name,queue_node_num,father_node_num,1,1,2,1,false);
  175. break;
  176. case 5:
  177. queue_node_num=search(node_name,queue_node_num,father_node_num,1,2,0,2,false);
  178. queue_node_num=    search(node_name,queue_node_num,father_node_num,1,2,2,2,false);
  179. queue_node_num=search(node_name,queue_node_num,father_node_num,1,2,1,1,true);
  180. break;
  181. case 6:
  182. queue_node_num=search(node_name,queue_node_num,father_node_num,2,0,1,0,false);
  183. queue_node_num=search(node_name,queue_node_num,father_node_num,2,0,2,1,true);
  184. break;
  185. case 7:
  186. queue_node_num= search(node_name,queue_node_num,father_node_num,2,1,2,0,true);
  187. queue_node_num=search(node_name,queue_node_num,father_node_num,2,1,2,2,true);
  188. queue_node_num=search(node_name,queue_node_num,father_node_num,2,1,1,1,false);
  189. break;
  190. case 8:
  191. queue_node_num=search(node_name,queue_node_num,father_node_num,2,2,2,2,true);
  192. queue_node_num=search(node_name,queue_node_num,father_node_num,2,2,1,2,false);
  193. break;
  194. default:   System.out.println("the location is error!");
  195. } }
  196. }}

我的节点类：

  1. public class node {
  2. int[][]  node_element= new  int[3][3];
  3. int node_name;
  4. int father_name;
  5. int location;
  6. node(int[][] node_element,int node_name,int father,int location){
  7. this.father_name=father;
  8. this.node_name=node_name;
  9. for(int i=0;i<=2;i++)
  10. for(int j=0;j<=2;j++)
  11. this.node_element[i][j]=node_element[i][j];
  12. this.location=location;
  13. }
  14. }

我这个写的比较水，我对复杂点数据结构的操作就搞不好了。最近好好总结一下！

转载于:https://blog.51cto.com/chinatong/1177147

广度优先搜索 解决九宫格问题相关推荐

  1. 广度优先搜索解决欧拉回路时间复杂度_迷宫搜索类的双向bfs问题(例题详解)

    前言 文章若有疏忽还请指正! 更多精彩还请关注公众号:bigsai 头条号:一直码农一直爽 在搜索问题中,以迷宫问题最具有代表性,无论是八皇后的回溯问题,还是dfs找出口,bfs找最短次数等等题目的问 ...

  2. java拯救公主_广度优先搜索解决“营救公主”问题

    在之前的一篇文章(迷宫营救公主算法)中提供了一个半成品的解决方案,之所以说他是半成品,是因为首先选择的算法就不对,采用的是深度优先搜索,其次也没有真正的用对深度优先算法,走过的点应该标记为已经走过,而 ...

  3. 八数码问题——双向广度优先搜索解决

    八数码问题:在3×3的方格棋盘上,摆放着1到8这八个数码,有1个方格是空的,其初始状态如图1所看到的,要求对空格运行空格左移.空格右移.空格上移和空格下移这四个操作使得棋盘从初始状态到目标状态. 搜索 ...

  4. 广度优先搜索：迷宫问题

    用广度优先搜索解决迷宫问题是一个比较基础的方法.由于自己在算法方面基础不是很好,并没有达到能随手就写出BFS的水平,所以花了点时间写了一个BFS来解决比较基础的迷宫问题,权当练习,并供自己以后参考. ...

  5. 广度搜索解决迷宫问题

    一 问题描述 用一个二维数组表示一个迷宫,其中 1 表示墙壁,0 表示可以走的路,只能横着走或竖着走,不能斜着走,编写程序,找出从左上角到右下角的最短路径. int maze[5][5] = { 0, ...

  6. LeetCode-365.水壶问题 广度优先搜索、费蜀定理

    这里是题目描述:LeetCode-365.水壶问题 方法一:广度优先搜索 对于容量分别为x和y的水壶h1.h2,我们将两水壶分别有v1和v2升水作为一种状态,可以从当前状态出发经过一定操作(倒水.装水 ...

  7. 从零开始的广度优先搜索(BFS)

    问题1: 什么是搜索? 搜索,是一个动态的,收集信息,分析信息,保存信息的循环过程.在循环的过程中,我们根据已知的信息,对探索方向进行调整.根据选择探索方向的策略,我们将搜索大致划分为"广度 ...

  8. 用BFS（广度优先搜索queuelist）算法解决农夫过河问题

    用BFS(广度优先搜索queue&&list)算法解决农夫过河问题 一.问题需求分析 一个农夫带着一只狼.一只羊和一棵白菜,身处河的南岸.他要把这些东西全部运到北岸.问题是他面前只有一 ...

  9. 八数码问题的广度优先搜索方法

    八数码问题的广度优先搜索方法 问题的简单描述 3×3九宫qipan,放置数码为1 -8的8个棋子,剩下一个空格,只能通过向空格的移动来改变九宫格的布局. 要求:根据给定初始布局(即初始状态)和目标布局 ...

  10. 广度优先算法解决8数码问题【c++】

    8数码问题 (广度优先算法解决----c++) 8数码问题问题描述 八数码问题也称为九宫问题,在3×3的棋盘上,摆有八个棋子,每个棋子上标有1至8的某一数字.棋盘中留有一个空格(空格用0来表示),空格 ...

最新文章

  1. android 图片切换，仿百叶窗效果
  2. Redis批量操作详解及性能分析
  3. Taro+react开发（13）--多加/不然不能跳转
  4. python爬取新闻存入数据库_python 爬取古诗文存入mysql数据库的方法
  5. 比特币在推特上的活跃度正接近2017年水平
  6. sharepoint2013的审核日志的时间区域设置
  7. SQL Server高级查询之子查询（子查询非典型应用）
  8. keystone系列二：HTTP协议
  9. CSDN博客下载器v1.0发布(Windows版本)
  10. 打印服务器 支持 佳能 2900+打印机,佳能LBP2900，夏普等特殊打印机如何实现打印？（虚拟USB软件用途之二）...
  11. 降级降薪去 Amazon ——左耳朵
  12. 信息安全技术国家相关标准一览表
  13. FCRD-P帆软考试总结
  14. php 豆瓣api_豆瓣申请API Key教程
  15. PHPoffice PHPword添加水印
  16. 计算机强制关机后无法正常启动,win10系统强制关机后无法正常启动了如何解决...
  17. B站头部UP主抱团垄断优质资源，腰部UP主的流量突破口在哪？
  18. Flex语法和常用鼠标手势
  19. 《惢客创业日记》2018.10.29（周一） 中国只有一个雷军，却有千万个中小企业
  20. 适合小白的Linux入门学习教程，从安装到实操（涵盖各种常用指令，超详细！）

热门文章

  1. 达观数据：Tornado原理浅析及应用场景探讨
  2. Julia: 引用与copy: 关于数组、自定义类型与初始化
  3. 机器学习笔记（四）：kNN算法 | 凌云时刻
  4. 图像下采样 matlab_MATLAB--数字图像处理 图像的采样与量化
  5. 【TSP】基于matlab自适应动态邻域布谷鸟混合算法求解旅行商问题【含Matlab源码 1513期】
  6. 【边缘检测】基于matlab蚁群算法图像边缘检测【含Matlab源码 1189期】
  7. 【机械仿真】基于matlab GUI智能电梯仿真系统【含Matlab源码 1087期】
  8. 【图像提取】基于matlab形态学矩阵块+线段提取【含Matlab源码 1014期】
  9. 【车间调度】基于matlab遗传算法求解混合流水车间调度最优问题【含Matlab源码 901期】
  10. 【手写字母识别】基于matlab GUI ELMAN+BP神经网络手写大写字母（A-O）识别【含Matlab源码 785期】