eight11.java

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

                     if( 展开(n,1,p,2,2,扩展节点) )            {没找到=false;  break;} 
                     //向左扩展 
                     if( 展开(n,2,p,1,1,扩展节点) )            {没找到=false;  break;} 
                 } 
                 else if(p[0] == 2 && p[1] == 0)//如果 点在左下角 
                 { 
                   //  System.out.println("0点在左下角"); 
                     //向上扩展 
                     if( 展开(n,0,p,1,0,扩展节点) )            {没找到=false;  break;} 
                     //向右扩展 
                     if( 展开(n,3,p,2,1,扩展节点) )           {没找到=false;  break;} 
                 } 
                 else if(p[0] == 2 && p[1] == 1)//如果 点在下边中间 
                 { 
                   //  System.out.println("0点在下边中间"); 
                     //向上扩展 
                     if( 展开(n,0,p,1,1,扩展节点) )            {没找到=false;  break;} 
                     //向左扩展 
                     if( 展开(n,2,p,2,0,扩展节点) )            {没找到=false;  break;} 
                     //向右扩展 
                     if( 展开(n,3,p,2,2,扩展节点) )            {没找到=false;  break;} 
                 } 
                 else if(p[0] == 2 && p[1] == 2)//如果 点在右下角 
                 { 
                   //  System.out.println("0点在右下角"); 
                     //向上扩展 
                     if( 展开(n,0,p,1,2,扩展节点) )            {没找到=false;  break;} 
                     //向左扩展 
                     if( 展开(n,3,p,2,1,扩展节点) )           {没找到=false;  break;}  
                 } 
                 n.用过吗=true; 
                 if(没找到) 
                 { 
                   for(int i =0;i<有值的个数(扩展节点);i++) 
 
 
 
{ 
                
                      open[opennum]=扩展节点[i]; 
                      opennum=opennum+1; 
                     } 
                      for(int i=0;i<有值的个数(扩展节点);i++) 
                     { 
                        扩展节点[i]=null; 
                     } 
                      
                      
                     System.out.println("测试加入"); 
                     for(int i=0;i<opennum;i++) 
                      { //if(open[i].用过吗=false) 
                         打印节点(open[i]); 
                         System.out.println("next one!"+open[i].用过吗);  
                      } 
                       
                      
                     n = 取最优节点(); 
                     System.out.println("最优节点:"); 
                     打印节点(n);//测试 
                     扩展_并查找节点(n); 
                     break; 
                 } 
     
        } 
    } 
     
    public boolean 存在否(节点 n)//判断节点在open表内是否存在 
    { 
        for(int i=0;i<opennum;i++) 
        { 
            if(open[i].等于(n)) return true; 
        } 
        return false; 
    } 
         
    public boolean 展开(节点 n,int k,int[] z,int q,int p,节点[] 扩展节点) 
    { 
        //展开(待扩展的节点,扩展方向,0点位置,方向行坐标,方向纵坐标,扩展临时节点数组) 
        节点 t = new 节点(n);  // 用父节点扩展 
        
        int flag = 0; 
        int temp; 
        temp = t.数码[z[0]][z[1]]; 
        t.数码[z[0]][z[1]] = t.数码[q][p]; 
        t.数码[q][p] = temp; 
         
        String msg=""; 
        if(k==0){ msg = new String("向上扩展结果");} 
        else if(k==1){ msg = new String("向下扩展结果");} 
        else if(k==2){ msg = new String("向左扩展结果");} 
        else if(k==3){ msg = new String("向右扩展结果");} 
        System.out.println(msg); 
        打印节点(t);//测试 
        if(!存在否(t))//如果不在open表中其 
        { 
            t.深度 = n.深度+1; 
            t.不相同节点个数 = t.不相同节点个数(目标节点); 
             
             t.father=n; 
             
            if(t.等于(目标节点)) 
            {  
                System.out.println("=======恭喜!终于找到目标节点了^-^!!!======="); 
                打印节点(t);//测试 
                最短路径[closednum]=t; 
                closednum = closednum+1; 
                // 最佳路径寻(目标节点); 
                 
                 for(int i=0;i<closednum;i++) 
                      { //if(open[i].用过吗=false) 
                         打印节点(最短路径[i]); 
                         System.out.println("next one!");  
                      } 
                 
                return true; 
            } 
            else {                 
                扩展节点[f] = t;//如果在open表中不存在则装入扩展节点数组中 
                f=f+1; 
            } 
            System.out.println("该节点的深度:"+t.深度+"\n该节点的不同与目标节点的个数:"+t.不相同节点个数); 
            int r = t.深度+t.不相同节点个数; 
            System.out.println("择优权值:"+r); 
            System.out.println(); 
        } 
        else  
        { 
            System.out.println("该节点已经分析过了"); 
            return false; 
        } 
        return false; 
    } 
     
    public 节点 取最优节点()//对open表排序找到最优的那个节点 
    { 
        节点 最优= new 节点();  
         
        System.out.println("open表内节点个数:"+ 有值的个数(open)); 
         
         
        最优 =open[opennum-1]; 
      最优.深度=100;最优.不相同节点个数=8; 
         
        for(int i=0;i<有值的个数(open);i++) 
        {    
            if((open[i].深度+open[i].不相同节点个数)<(最优.深度+最优.不相同节点个数) && !open[i].用过吗) 
            { 
                最优 =open[i]; 
            } 
        } 
        
        //从open表中取出最优节点,放入closed表中 
       
        最短路径[closednum]=最优; 
        closednum = closednum+1; 
        f=0;//重置扩展数组下标 
        
        return 最优; 
     } 
      
    public void 最佳路径寻(节点 目标节点) 
    { 
     if(!初始节点.等于(目标节点.father)) 
        最佳路径寻(目标节点.father); 
        打印节点(目标节点); 
           
    } 
    
  
    public static int 有值的个数(节点 m[])//确定节点内的个数 
    { 
        int n =0; 
        for(int i=0;i<m.length;i++) 
        { 
            if(m[i] != null) n=n+1; 
            if(m[i] == null) break; 
        }           
        return n; 
    } 
    
    public static void main(String args[]) 
    { 
       
      
       
     int a1[]={2,8,3,1,6,4,7,0,5}; 
     int a2[]={1,2,3,8,0,4,7,6,5}; 
   
    // int a1[]={1,2,3,4,5,6,7,8,0}; 
    // int a2[]={0,2,3,4,5,6,7,8,1}; 
  
            eight11 bsm = new eight11(a1,a2); 
             
       
         bsm.扩展_并查找节点(bsm.初始节点); 
         
         
        
            System.out.println("应用程序终止"); 
          
    } 
}