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+="
";
            }
            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);
        }
    }
}

---