BFS实现8数码问题，思考与总结

BFS实现8数码问题，思考与总结

---

今天中午学习了二叉树的线索化与线索化遍历，突然有一种想实现八数码问题的冲动，因为它的初级解决方式是BFS（广度优先搜索算法）。于是我开始编程。

没想到一编就是一个下午，一直编到了晚上8点。期间出现了很多问题。

1.拷贝函数拷贝完之后，对目标对象进行的操作，会影响源对象。

原来的代码：

             ints(ints obj){//拷贝构造函数
             int i,j;
             data=new myInt[3][3];
             for(i=0;i<3;i++) for(j=0;j<3;j++){//拷贝data
                 data[i][j]=obj.data[i][j];//问题点
             }
             this.parent=obj.parent;}//拷贝父编号

修改后：

         ints(ints obj){//拷贝构造函数
             int i,j;
             data=new myInt[3][3];
             for(i=0;i<3;i++) for(j=0;j<3;j++){//拷贝data
                 data[i][j]=new myInt();
                 data[i][j].set(obj.data[i][j].get());
             }
             this.parent=obj.parent;//拷贝父编号
         }

这个问题涉及到了java的对象引用方式。在出现问题的语句上，我直接使用了“=”进行赋值，传给等号左边的相当于只是右边的指针，而不是值，因为没有用“new”新建对象。修改后，新建了对象，并且进行了传值。

2.程序能跑起来，但是一直处于循环状态，无法跑出正确的答案。

开始我按照脑海里的“BFS是树的按层遍历”来编制代码。写完后发现出现了问题。

原先的代码：

         while(front<rear){
             int lastRear=rear;                        //临时队尾
             for(int i=front;i<lastRear;i++){        //树的按层遍历。对当前层全部执行出队操作。
                 ints tmp=queue.get(front++);        //出队
                 //对这个出队节点进行四个方向上的变换，构造出新的叶子节点，让他们入队
                 for(int j=0;j<4;j++){                //进行4个方向上的变换
                     ints node=new ints(tmp);        //拷贝出新的结点
                     if(node.Move(j) && (!FindInQueue(node)) ){        //如果变换成功 并且这个结点在队列中是新的
                         node.parent=front-1;
                         if(node.FindTarget(target)){
                             System.out.println("找到");
                             System.out.println(node);
                             return;        //找到目标，跳出循环
                         }
                         queue.add(node);
                         rear++;                        //入队
                         System.out.println(node);
                     }
                 }
             }
         }

按层遍历是试用一个队列，首先根节点入队，然后由根节点派生出叶子节点入队，遍历每一层，使树一层一层增加，进行遍历。

java源码

 import java.util.*;

 public class demo {

     public demo() {
         // TODO Auto-generated constructor stub
     }

     public static void main(String[] args) {
         EightNumProblem proble=new EightNumProblem();
         proble.solve();
     }

 }

 class EightNumProblem{
     int source[][] ={{1,2,3},{4,5,0},{6,7,8}};//构造一个二维 3 * 3 数组【源数据】
     int target[][] ={{1,2,3},{4,5,6},{7,8,0}};//构造一个二维 3 * 3 数组【目标数据】
     class myInt{
         int i=0;
         int get(){return i;}
         void set(int in){i=in;}
         myInt(){}
         myInt(int in){i=in;}
     }
     class ints{            //解决问题的数据结构。
         protected myInt[][] data=new myInt[3][3];//内部数据
         protected int parent;//父编号，用于回溯
         ints(){

         }
         ints(ints obj){//拷贝构造函数
             int i,j;
             data=new myInt[3][3];
             for(i=0;i<3;i++) for(j=0;j<3;j++){//拷贝data
                 data[i][j]=new myInt();
                 data[i][j].set(obj.data[i][j].get());
             }
             this.parent=obj.parent;//拷贝父编号
         }
         ints(int[][] in){
             int i,j;
             for(i=0;i<3;i++) for(j=0;j<3;j++) data[i][j]=new myInt(in[i][j]);
         }
         int get(int i,int j){
             return data[i][j].get();
         }
         void set(int i,int j,int in){
             data[i][j].set(in);
         }
         public String toString(){//重写用于打印
             int i,j;
             String re=new String("");
             for(i=0;i<3;i++){
                 for(j=0;j<3;j++){
                     re+=Integer.toString(data[i][j].get());
                     if(j!=2) re+=",";}
                 re+="\n";
             }
             return re;
         }
         void FindPos(int target,myInt X,myInt Y){//寻找目标元素，并传指 X、Y 返回。
             int i,j;
             for(i=0;i<3;i++) for(j=0;j<3;j++) if(target==data[i][j].get()){//循环，找到目标元素
                 X.set(i);//传指
                 Y.set(j);
                 return;
             }
         }
         boolean Move(int mod){
             myInt X=new myInt();
             myInt Y=new myInt();
             FindPos(0,X,Y);
             int x=X.get();
             int y=Y.get();//找到0的位置
         //    System.out.println("x="+x+"y="+y);
             switch(mod){
             case 0://上
                 if(y>0) swap(x,y,x,y-1);
                 else return false;
                 break;
             case 1://下
                 if(y<2) swap(x,y,x,y+1);
                 else return false;
                 break;
             case 2://左
                 if(x>0) swap(x,y,x-1,y);
                 else return false;
                 break;
             default://右
                 if(x<2) swap(x,y,x+1,y);
                 else return false;
                 break;
             }
             return true;
         }
         void swap(int x1,int y1,int x2,int y2){//(x1,y1)与(x2,y2)交换
             int tmp=data[x1][y1].get();                //tmp=x1
             data[x1][y1].set(data[x2][y2].get());    //x1=x2
             data[x2][y2].set(tmp);                    //x2=tmp
         }
         boolean FindTarget(int[][] obj){//找到目标
             int i,j;
             for(i=0;i<3;i++) for(j=0;j<3;j++) if(obj[i][j]!=data[i][j].get()) return false;//只要有一个不符，错误
             return true;
         }
         boolean equalWith(ints obj){//与目标相同
             int i,j;
             for(i=0;i<3;i++)
                 for(j=0;j<3;j++)
                     if(obj.data[i][j].get()!=data[i][j].get()) return false;//只要有一个不符，错误
             return true;
         }
     }

     List<ints> queue=new ArrayList<ints>();//设置队列

     EightNumProblem(){}

     boolean FindInQueue(ints elem){//查看队列中是否有该元素
         for(int i=0;i<queue.size();i++){
             if(elem.equalWith(queue.get(i))){
                 return true;
             }
         }

         return false;
     }

     void solve(){
         ints root=new ints(source);//用源数据构造根节点
         root.parent=-1;//父编号设置特殊值: -1
         int front=0;
         int rear=0;
         queue.add(root);//根节点入队
         rear++;
         int flag=0;
         while(front<rear && flag<100000){
             for(int j=0;j<4;j++){
                 flag++;
                 ints tmp=queue.get(front);        //出队
                 ints node=new ints(tmp);        //拷贝出新的结点
                 if(node.Move(j) && (!FindInQueue(node)) ){        //如果变换成功 并且这个结点在队列中是新的
                     node.parent=front;
                     if(node.FindTarget(target)){
                         System.out.println("找到");
                         PrintSource(node);
                         return;        //找到目标，跳出循环
                     }
                     queue.add(node);
                     rear++;                        //入队
                 }
             }
             front++;
         }
     }
     void PrintSource(ints obj){
         while(obj.parent!=-1){
             System.out.println(obj);
             obj=queue.get(obj.parent);
         }
     }
 }

---