eight11.java

八数码游戏。可运行于JAVA环境下

public class eight11  
{ 
     
    节点 初始节点;  
    节点 目标节点; 
     
    节点 扩展节点[] = new 节点[4]; //保存父节点的四个子节点,顺序存储为上，下，左，右，为扩展的临时数组 
    int f=0;//扩展节点的下标 
  
    节点 open[] = new 节点[100];  //扩展节点类 
     
    节点 最短路径[] = new 节点[100];//相当与closed表 
     
    int opennum=0;//open表中节点的个数 
     
    int closednum =0;//closed表中节点的个数s 
     
    eight11(int a1[],int a2[])//构造方法两个参数  数组 
    { 
        初始节点 = new 节点(a1); 
       
        目标节点 = new 节点(a2);  
         
        初始节点.不相同节点个数 = 初始节点.不相同节点个数(目标节点); 
        目标节点.不相同节点个数 = 目标节点.不相同节点个数(目标节点); 
         
        System.out.println("初始节点 的 不同点的个数:"+初始节点.不相同节点个数); 
    } 
    public class 节点  //节点这样一个结构体是关键之一 
    {   
        int 深度,不相同节点个数; 
         
        int 数码[][] = new int[3][3]; 
         
        boolean 用过吗; 
         
        节点 father; 
        
        public 节点() //无参数的构造方法 
        { 
            用过吗 = false; 
        } 
        public 节点(节点 n)//参数是一个节点的构造方法建立一个新的节点并且和原来的一样 
        { 
            深度 = n.深度; 
            for(int i=0;i<3;i++) 
                for(int j=0;j<3;j++) 
                        数码[i][j]=n.数码[i][j]; 
            不相同节点个数 = n.不相同节点个数; 
            用过吗 = n.用过吗; 
        } 
        public 节点(int a[])//参数是一个数组 得到的新的节点是一个0到8的数组成二维的 
        { 
            int m=0; 
            for(int i=0;i<3;i++) 
                for(int j=0;j<3;j++) 
                    { 
                        数码[i][j]=a[m]; 
                        m=m+1; 
                    } 
             
            用过吗 = false; 
            深度=0;  
           System.out.println("测试4确保成功给值！");//测试 
        } 
        public int[][] 取数值()//方法可以获得节点的首地址也就是他的内容 
        { 
            return 数码; 
        } 
        public boolean 等于(节点 st)//只是数码不相等//判断两个节点是不是相同 
        { 
            int[][] s = st.取数值(); 
            int i,j; 
            for (i = 0; i < 3; i++) 
                for(j = 0 ; j<3 ;j++) 
                if (s[i][j] != this.数码[i][j]) 
                    return false; 
            return true; 
        }  
         
        public int[] 零点位置()//获得节点中0点的位置 
        { 
            int 位置[] = new int[2]; 
            for(int i=0;i<3;i++) 
                for(int j=0;j<3;j++) 
                    if(this.数码[i][j]==0) 
                        {位置[0]=i;位置[1]=j;} 
            return 位置;                 
        } 
         
        public int 不相同节点个数(节点 a)//获得不相同节点的个数不 
        { 
            int m = 0; 
            for(int i=0 ; i<3 ; i++) 
                for(int j=0; j<3 ;j++) 
                    { if( a.数码[i][j] == this.数码[i][j] && a.数码[i][j]!=0 ) m=m+1;} 
            return 8-m; 
        } 
    } 
     
    public static void 打印节点(节点 h) //输出节点的内容 
    { 
        for(int i=0;i<3;i++) 
        { 
            for(int j=0;j<3;j++) 
                { 
                 System.out.print(h.数码[i][j]+" "); 
                } 
            System.out.println(); 
        } 
    } 
   
    public void 扩展_并查找节点(节点 n)//看名字就知道是在干什么了！ 
    { 
      //  节点 t = new 节点();     //得到一个空的节点   
         
        int temp = 0;                 //交换数码的中间变量 
      boolean 没找到 = true;  
       
        if (初始节点.等于(目标节点)) 
              { 没找到=false; 
               System.out.println("没有必要了!");} 
        while(没找到) 
       {     
                if (n.等于(目标节点)) 
                { 
                 System.out.println("没有必要了!");break; 
                 } 
           
                 if(n.等于(初始节点)) 
                { 
                   open[opennum]=n;        // （状态位置,节点对象)  
                   
               
                   opennum=opennum+1; 
                    最短路径[closednum]=n; 
                    closednum=closednum+1; 
                     
                    System.out.println("测试 第一次展开"); 
                 } 
                 int[] p= n.零点位置();//知道0的位置                                  
                 System.out.println("=================================待扩展的节点;================================"); 
                  
                 打印节点(n);//测试 
                
                 
                 
                 System.out.println("0点位置:"+p[0]+" "+p[1]); 
                 if(p[0]==0 && p[1]==0)//如果0点在左上角 
                 {                                      
                    //展开(待扩展的节点,扩展方向,0点位置,方向行坐标,方向纵坐标,扩展临时节点数组); 
                    //向下扩展  
                    if( 展开(n,1,p,1,0,扩展节点) )         {没找到=false;  break;} 
                    //向右扩展   
                    if( 展开(n,3,p,0,1,扩展节点) )            {没找到=false;  break;} 
                 } 
                 else if(p[0] == 0 && p[1] == 1)//如果0点在上中间的话 
                 { 
                     System.out.println("0点在上中间"); 
                     //向下扩展 
                     if( 展开(n,1,p,1,1,扩展节点) )            {没找到=false;  break;} 
                     //向左扩展 
                     if( 展开(n,2,p,0,0,扩展节点) )            {没找到=false;  break;} 
                     //向右扩展 
                     if( 展开(n,3,p,0,2,扩展节点) )            {没找到=false;  break;} 
                 }                  
                 else if(p[0] == 0 && p[1] == 2)//如果0点在右上角 
                 { 
                     System.out.println("0点在右上角"); 
                     //向下扩展 
                     if( 展开(n,1,p,1,2,扩展节点) )           {没找到=false;  break;} 
                     //向左扩展 
                     if( 展开(n,2,p,0,1,扩展节点) )           {没找到=false;  break;}                     
                 } 
                 else if(p[0] == 1 && p[1] == 0)//如果 点在左边中间 
                 { 
System.out.println("0点在左边中间"); 
                     //向上扩展 
                     if( 展开(n,0,p,0,0,扩展节点) )           {没找到=false;  break;} 
                     //向下扩展 
                     if( 展开(n,1,p,2,0,扩展节点) )            {没找到=false;  break;} 
                     //向右扩展 
                     if( 展开(n,3,p,1,1,扩展节点) )            {没找到=false;  break;}                     
                 } 
                 else if(p[0] == 1 && p[1] == 1)//如果 点在正中间 
                 { 
                     System.out.println("0点在正中间"); 
                     //向上扩展 
                     if( 展开(n,0,p,0,1,扩展节点) )           {没找到=false;  break;} 
                     //向下扩展 
                     if( 展开(n,1,p,2,1,扩展节点) )            {没找到=false;  break;} 
                     //向左扩展 
                     if( 展开(n,2,p,1,0,扩展节点) )           {没找到=false;  break;} 
                     //向右扩展 
                     if( 展开(n,3,p,1,2,扩展节点) )           {没找到=false;  break;} 
                 } 
                 else if(p[0] == 1 && p[1] == 2)//如果 点在右边中间 
                 { 
                   //  System.out.println("0点在右边中间"); 
                     //向上扩展 
                     if( 展开(n,0,p,0,2,扩展节点) )           {没找到=false;  break;} 
                     //向下扩展