深度优先、广度优先和A*算法实现的重排九宫问题

  • 问题描述

在3×3的方格上分别放置1,2,3,4,5,6,7,8,9的八张排,初始状态为S0,目标状态为Sg,计算出从S0到Sg的方法。

  • 代码及说明 《深度优先、广度优先和A*算法实现的重排九宫问题》 《深度优先、广度优先和A*算法实现的重排九宫问题》 /**/ /******************************************************************************
    《深度优先、广度优先和A*算法实现的重排九宫问题》 * 使用深度优先、广度优先和A*算法解决九宫问题
    《深度优先、广度优先和A*算法实现的重排九宫问题》*****************************************************************************
    */

    《深度优先、广度优先和A*算法实现的重排九宫问题》
    《深度优先、广度优先和A*算法实现的重排九宫问题》#include
    < stdio.h >
    《深度优先、广度优先和A*算法实现的重排九宫问题》#include
    < iostream.h >
    《深度优先、广度优先和A*算法实现的重排九宫问题》#include
    < string .h >
    《深度优先、广度优先和A*算法实现的重排九宫问题》#include
    < stdlib.h >
    《深度优先、广度优先和A*算法实现的重排九宫问题》
    《深度优先、广度优先和A*算法实现的重排九宫问题》
    《深度优先、广度优先和A*算法实现的重排九宫问题》
    《深度优先、广度优先和A*算法实现的重排九宫问题》#include
    data.h
    《深度优先、广度优先和A*算法实现的重排九宫问题》#include
    queue.h
    《深度优先、广度优先和A*算法实现的重排九宫问题》#include
    stack.h
    《深度优先、广度优先和A*算法实现的重排九宫问题》#include
    link.h
    《深度优先、广度优先和A*算法实现的重排九宫问题》
    《深度优先、广度优先和A*算法实现的重排九宫问题》
    《深度优先、广度优先和A*算法实现的重排九宫问题》
    #define  DEEPSEARCH    1    
    《深度优先、广度优先和A*算法实现的重排九宫问题》
    #define  WIDESEARCH    2    
    《深度优先、广度优先和A*算法实现的重排九宫问题》
    #define  ASTART    3        
    《深度优先、广度优先和A*算法实现的重排九宫问题》
    《深度优先、广度优先和A*算法实现的重排九宫问题》
    #define  SEARCHTYPE WIDESEARCH    // 定义使用广度优先
    《深度优先、广度优先和A*算法实现的重排九宫问题》
    《深度优先、广度优先和A*算法实现的重排九宫问题》
    《深度优先、广度优先和A*算法实现的重排九宫问题》
    // #define SHOWPROCESS     // 定义是否显示中间过程
    《深度优先、广度优先和A*算法实现的重排九宫问题》

    《深度优先、广度优先和A*算法实现的重排九宫问题》
    《深度优先、广度优先和A*算法实现的重排九宫问题》
    《深度优先、广度优先和A*算法实现的重排九宫问题》《深度优先、广度优先和A*算法实现的重排九宫问题》
    class  SearchTree {    
    《深度优先、广度优先和A*算法实现的重排九宫问题》
    private:
    《深度优先、广度优先和A*算法实现的重排九宫问题》《深度优先、广度优先和A*算法实现的重排九宫问题》
    /**//***********************定义open表的数据类型************************/
    《深度优先、广度优先和A*算法实现的重排九宫问题》
    #if SEARCHTYPE==WIDESEARCH
    《深度优先、广度优先和A*算法实现的重排九宫问题》    Queue open;
    《深度优先、广度优先和A*算法实现的重排九宫问题》
    #elif SEARCHTYPE==DEEPSEARCH
    《深度优先、广度优先和A*算法实现的重排九宫问题》    Stack open;
    《深度优先、广度优先和A*算法实现的重排九宫问题》
    #else    
    《深度优先、广度优先和A*算法实现的重排九宫问题》    Link open;
    《深度优先、广度优先和A*算法实现的重排九宫问题》
    #endif
    《深度优先、广度优先和A*算法实现的重排九宫问题》
    《深度优先、广度优先和A*算法实现的重排九宫问题》
    《深度优先、广度优先和A*算法实现的重排九宫问题》    Stack close;
    《深度优先、广度优先和A*算法实现的重排九宫问题》
    public:
    《深度优先、广度优先和A*算法实现的重排九宫问题》    
    void init();    //初始化数据
    《深度优先、广度优先和A*算法实现的重排九宫问题》
        void extend();       //扩展close表尾节点并添加进open表
    《深度优先、广度优先和A*算法实现的重排九宫问题》    void moveToClose();    //将open表的头节点移动到close表中
    《深度优先、广度优先和A*算法实现的重排九宫问题》
        bool success();        //判断搜索是否成功
    《深度优先、广度优先和A*算法实现的重排九宫问题》
        bool openEmpty();    //判断open表是否为空
    《深度优先、广度优先和A*算法实现的重排九宫问题》
        void showAnswer();    //显示最终结果
    《深度优先、广度优先和A*算法实现的重排九宫问题》
    }
    ;
    《深度优先、广度优先和A*算法实现的重排九宫问题》
    《深度优先、广度优先和A*算法实现的重排九宫问题》《深度优先、广度优先和A*算法实现的重排九宫问题》
    void  SearchTree::showAnswer() {
    《深度优先、广度优先和A*算法实现的重排九宫问题》    close.show();
    《深度优先、广度优先和A*算法实现的重排九宫问题》}

    《深度优先、广度优先和A*算法实现的重排九宫问题》
    《深度优先、广度优先和A*算法实现的重排九宫问题》《深度优先、广度优先和A*算法实现的重排九宫问题》
    bool  SearchTree::openEmpty() {
    《深度优先、广度优先和A*算法实现的重排九宫问题》    
    return open.empty();
    《深度优先、广度优先和A*算法实现的重排九宫问题》}

    《深度优先、广度优先和A*算法实现的重排九宫问题》
    《深度优先、广度优先和A*算法实现的重排九宫问题》
    《深度优先、广度优先和A*算法实现的重排九宫问题》《深度优先、广度优先和A*算法实现的重排九宫问题》
    void  SearchTree::extend() {
    《深度优先、广度优先和A*算法实现的重排九宫问题》    DATATYPE temp[LINE][ROW],buf[LINE][ROW];
    《深度优先、广度优先和A*算法实现的重排九宫问题》    Data 
    *pid;
    《深度优先、广度优先和A*算法实现的重排九宫问题》    
    int n,m;
    《深度优先、广度优先和A*算法实现的重排九宫问题》    pid
    =close.getTop(*buf);    //将close表的最后一项记录复制到buf中
    《深度优先、广度优先和A*算法实现的重排九宫问题》
        for(n=0;n<LINE;n++)
    《深度优先、广度优先和A*算法实现的重排九宫问题》        
    for(m=0;m<ROW;m++)
    《深度优先、广度优先和A*算法实现的重排九宫问题》            
    if(buf[n][m]==0)//寻找buf中0所在的位置,0表示空格
    《深度优先、广度优先和A*算法实现的重排九宫问题》
                    goto L1;
    《深度优先、广度优先和A*算法实现的重排九宫问题》L1:
    《深度优先、广度优先和A*算法实现的重排九宫问题》
    《深度优先、广度优先和A*算法实现的重排九宫问题》
    《深度优先、广度优先和A*算法实现的重排九宫问题》    memcpy(temp,buf,DATASIZE
    *sizeof(DATATYPE));    
    《深度优先、广度优先和A*算法实现的重排九宫问题》《深度优先、广度优先和A*算法实现的重排九宫问题》    
    if(n!=0){    //空格上移
    《深度优先、广度优先和A*算法实现的重排九宫问题》
            temp[n][m]=temp[n1][m];
    《深度优先、广度优先和A*算法实现的重排九宫问题》        temp[n
    1][m]=0;
    《深度优先、广度优先和A*算法实现的重排九宫问题》        
    if(close.exist(*temp)==false) open.push(*temp,&pid);
    《深度优先、广度优先和A*算法实现的重排九宫问题》#ifdef SHOWPROCESS    
    //宏定义,决定时候输出中间过程
    《深度优先、广度优先和A*算法实现的重排九宫问题》
            cout<<move below data to open table:<<endl;
    《深度优先、广度优先和A*算法实现的重排九宫问题》        showElement(
    *temp);
    《深度优先、广度优先和A*算法实现的重排九宫问题》        getchar();
    《深度优先、广度优先和A*算法实现的重排九宫问题》
    #endif
    《深度优先、广度优先和A*算法实现的重排九宫问题》    }

    《深度优先、广度优先和A*算法实现的重排九宫问题》
    《深度优先、广度优先和A*算法实现的重排九宫问题》
    《深度优先、广度优先和A*算法实现的重排九宫问题》
    《深度优先、广度优先和A*算法实现的重排九宫问题》    memcpy(temp,buf,DATASIZE
    *sizeof(DATATYPE));
    《深度优先、广度优先和A*算法实现的重排九宫问题》《深度优先、广度优先和A*算法实现的重排九宫问题》    
    if(n!=2){    //空格下移
    《深度优先、广度优先和A*算法实现的重排九宫问题》
            temp[n][m]=temp[n+1][m];
    《深度优先、广度优先和A*算法实现的重排九宫问题》        temp[n
    +1][m]=0;
    《深度优先、广度优先和A*算法实现的重排九宫问题》        
    if(close.exist(*temp)==false) open.push(*temp,&pid);
    《深度优先、广度优先和A*算法实现的重排九宫问题》#ifdef SHOWPROCESS
    《深度优先、广度优先和A*算法实现的重排九宫问题》        cout
    <<move below data to open table:<<endl;
    《深度优先、广度优先和A*算法实现的重排九宫问题》        showElement(
    *temp);
    《深度优先、广度优先和A*算法实现的重排九宫问题》        getchar();
    《深度优先、广度优先和A*算法实现的重排九宫问题》
    #endif
    《深度优先、广度优先和A*算法实现的重排九宫问题》    }

    《深度优先、广度优先和A*算法实现的重排九宫问题》    
    《深度优先、广度优先和A*算法实现的重排九宫问题》    memcpy(temp,buf,DATASIZE
    *sizeof(DATATYPE));
    《深度优先、广度优先和A*算法实现的重排九宫问题》《深度优先、广度优先和A*算法实现的重排九宫问题》    
    if(m!=0){    //空格左移
    《深度优先、广度优先和A*算法实现的重排九宫问题》
            temp[n][m]=temp[n][m1];
    《深度优先、广度优先和A*算法实现的重排九宫问题》        temp[n][m
    1]=0;
    《深度优先、广度优先和A*算法实现的重排九宫问题》        
    if(close.exist(*temp)==false) open.push(*temp,&pid);
    《深度优先、广度优先和A*算法实现的重排九宫问题》#ifdef SHOWPROCESS
    《深度优先、广度优先和A*算法实现的重排九宫问题》        cout
    <<move below data to open table:<<endl;
    《深度优先、广度优先和A*算法实现的重排九宫问题》        showElement(
    *temp);
    《深度优先、广度优先和A*算法实现的重排九宫问题》        getchar();
    《深度优先、广度优先和A*算法实现的重排九宫问题》
    #endif
    《深度优先、广度优先和A*算法实现的重排九宫问题》    }

    《深度优先、广度优先和A*算法实现的重排九宫问题》
    《深度优先、广度优先和A*算法实现的重排九宫问题》    
    《深度优先、广度优先和A*算法实现的重排九宫问题》    memcpy(temp,buf,DATASIZE
    *sizeof(DATATYPE));
    《深度优先、广度优先和A*算法实现的重排九宫问题》《深度优先、广度优先和A*算法实现的重排九宫问题》    
    if(m!=2){    //空格右移
    《深度优先、广度优先和A*算法实现的重排九宫问题》
            temp[n][m]=temp[n][m+1];
    《深度优先、广度优先和A*算法实现的重排九宫问题》        temp[n][m
    +1]=0;
    《深度优先、广度优先和A*算法实现的重排九宫问题》        
    if(close.exist(*temp)==false) open.push(*temp,&pid);
    《深度优先、广度优先和A*算法实现的重排九宫问题》#ifdef SHOWPROCESS
    《深度优先、广度优先和A*算法实现的重排九宫问题》        cout
    <<move below data to open table:<<endl;
    《深度优先、广度优先和A*算法实现的重排九宫问题》        showElement(
    *temp);
    《深度优先、广度优先和A*算法实现的重排九宫问题》        getchar();
    《深度优先、广度优先和A*算法实现的重排九宫问题》
    #endif
    《深度优先、广度优先和A*算法实现的重排九宫问题》    }

    《深度优先、广度优先和A*算法实现的重排九宫问题》
    《深度优先、广度优先和A*算法实现的重排九宫问题》
    《深度优先、广度优先和A*算法实现的重排九宫问题》
    《深度优先、广度优先和A*算法实现的重排九宫问题》}

    《深度优先、广度优先和A*算法实现的重排九宫问题》
    《深度优先、广度优先和A*算法实现的重排九宫问题》《深度优先、广度优先和A*算法实现的重排九宫问题》
    void  SearchTree::moveToClose() {
    《深度优先、广度优先和A*算法实现的重排九宫问题》    DATATYPE dt[DATASIZE];
    《深度优先、广度优先和A*算法实现的重排九宫问题》    Data 
    *pid;
    《深度优先、广度优先和A*算法实现的重排九宫问题》    open.pop(dt,
    &pid);
    《深度优先、广度优先和A*算法实现的重排九宫问题》    close.push(dt,
    &pid);    
    《深度优先、广度优先和A*算法实现的重排九宫问题》}

    《深度优先、广度优先和A*算法实现的重排九宫问题》
    《深度优先、广度优先和A*算法实现的重排九宫问题》
    《深度优先、广度优先和A*算法实现的重排九宫问题》《深度优先、广度优先和A*算法实现的重排九宫问题》
    bool  SearchTree::success() {
    《深度优先、广度优先和A*算法实现的重排九宫问题》    DATATYPE dt[DATASIZE];
    《深度优先、广度优先和A*算法实现的重排九宫问题》    close.getTop(dt);
    《深度优先、广度优先和A*算法实现的重排九宫问题》    
    return memcmp(dt,*sg,DATASIZE*sizeof(DATATYPE))?  false:true;
    《深度优先、广度优先和A*算法实现的重排九宫问题》}

    《深度优先、广度优先和A*算法实现的重排九宫问题》
    《深度优先、广度优先和A*算法实现的重排九宫问题》《深度优先、广度优先和A*算法实现的重排九宫问题》
    void  SearchTree::init() {
    《深度优先、广度优先和A*算法实现的重排九宫问题》    open.init();
    《深度优先、广度优先和A*算法实现的重排九宫问题》    close.init();
    《深度优先、广度优先和A*算法实现的重排九宫问题》    
    //初始节点S0
    《深度优先、广度优先和A*算法实现的重排九宫问题》
        s0[0][0]=2;s0[0][1]=8;s0[0][2]=3;
    《深度优先、广度优先和A*算法实现的重排九宫问题》    s0[
    1][0]=1;s0[1][1]=0;s0[1][2]=4;
    《深度优先、广度优先和A*算法实现的重排九宫问题》    s0[
    2][0]=7;s0[2][1]=6;s0[2][2]=5;
    《深度优先、广度优先和A*算法实现的重排九宫问题》    
    //目标节点Sg
    《深度优先、广度优先和A*算法实现的重排九宫问题》
        sg[0][0]=1;sg[0][1]=2;sg[0][2]=3;
    《深度优先、广度优先和A*算法实现的重排九宫问题》    sg[
    1][0]=8;sg[1][1]=0;sg[1][2]=4;
    《深度优先、广度优先和A*算法实现的重排九宫问题》    sg[
    2][0]=7;sg[2][1]=6;sg[2][2]=5;
    《深度优先、广度优先和A*算法实现的重排九宫问题》    
    //显示信息
    《深度优先、广度优先和A*算法实现的重排九宫问题》
        cout<<s0:<<endl;
    《深度优先、广度优先和A*算法实现的重排九宫问题》    showElement(
    *s0);
    《深度优先、广度优先和A*算法实现的重排九宫问题》    cout
    <<sg:<<endl;
    《深度优先、广度优先和A*算法实现的重排九宫问题》    showElement(
    *sg);
    《深度优先、广度优先和A*算法实现的重排九宫问题》    cout
    <<any key to continue<<endl;
    《深度优先、广度优先和A*算法实现的重排九宫问题》    getchar();
    《深度优先、广度优先和A*算法实现的重排九宫问题》
    《深度优先、广度优先和A*算法实现的重排九宫问题》    open.push(
    *s0,NULL);
    《深度优先、广度优先和A*算法实现的重排九宫问题》#ifdef SHOWPROCESS    
    《深度优先、广度优先和A*算法实现的重排九宫问题》    cout
    <<below data move to open table:<<endl;
    《深度优先、广度优先和A*算法实现的重排九宫问题》    showElement(
    *s0);
    《深度优先、广度优先和A*算法实现的重排九宫问题》
    #endif
    《深度优先、广度优先和A*算法实现的重排九宫问题》
    《深度优先、广度优先和A*算法实现的重排九宫问题》}

    《深度优先、广度优先和A*算法实现的重排九宫问题》
    《深度优先、广度优先和A*算法实现的重排九宫问题》
    《深度优先、广度优先和A*算法实现的重排九宫问题》《深度优先、广度优先和A*算法实现的重排九宫问题》
    void  main() {
    《深度优先、广度优先和A*算法实现的重排九宫问题》
    #if SEARCHTYPE==WIDESEARCH
    《深度优先、广度优先和A*算法实现的重排九宫问题》    puts(
    wide search); 
    《深度优先、广度优先和A*算法实现的重排九宫问题》
    #elif SEARCHTYPE==DEEPSEARCH
    《深度优先、广度优先和A*算法实现的重排九宫问题》    puts(
    deep search); 
    《深度优先、广度优先和A*算法实现的重排九宫问题》
    #else    
    《深度优先、广度优先和A*算法实现的重排九宫问题》    puts(
    astart search);
    《深度优先、广度优先和A*算法实现的重排九宫问题》
    #endif
    《深度优先、广度优先和A*算法实现的重排九宫问题》    SearchTree st;
    《深度优先、广度优先和A*算法实现的重排九宫问题》    st.init();    
    《深度优先、广度优先和A*算法实现的重排九宫问题》《深度优先、广度优先和A*算法实现的重排九宫问题》    
    while(1){
    《深度优先、广度优先和A*算法实现的重排九宫问题》        
    //open表为空,问题无解
    《深度优先、广度优先和A*算法实现的重排九宫问题》《深度优先、广度优先和A*算法实现的重排九宫问题》
            if(st.openEmpty()==true){    
    《深度优先、广度优先和A*算法实现的重排九宫问题》            cout
    <<there is no answer for this question, open table is empty<<endl;
    《深度优先、广度优先和A*算法实现的重排九宫问题》            exit(
    0);
    《深度优先、广度优先和A*算法实现的重排九宫问题》        }

    《深度优先、广度优先和A*算法实现的重排九宫问题》        
    //将open表的表头移动到close表中
    《深度优先、广度优先和A*算法实现的重排九宫问题》
            st.moveToClose();            
    《深度优先、广度优先和A*算法实现的重排九宫问题》        
    //判断是否搜索成功
    《深度优先、广度优先和A*算法实现的重排九宫问题》《深度优先、广度优先和A*算法实现的重排九宫问题》
            if(st.success()==true){        
    《深度优先、广度优先和A*算法实现的重排九宫问题》            cout
    <<get answer:<<endl;
    《深度优先、广度优先和A*算法实现的重排九宫问题》            st.showAnswer();
    《深度优先、广度优先和A*算法实现的重排九宫问题》            exit(
    0);
    《深度优先、广度优先和A*算法实现的重排九宫问题》        }

    《深度优先、广度优先和A*算法实现的重排九宫问题》        
    //扩展close表
    《深度优先、广度优先和A*算法实现的重排九宫问题》
            st.extend();                
    《深度优先、广度优先和A*算法实现的重排九宫问题》    }

    《深度优先、广度优先和A*算法实现的重排九宫问题》}

 

《深度优先、广度优先和A*算法实现的重排九宫问题》
《深度优先、广度优先和A*算法实现的重排九宫问题》
/**/
/*********************************************************
《深度优先、广度优先和A*算法实现的重排九宫问题》 * data.h
《深度优先、广度优先和A*算法实现的重排九宫问题》 * 定义基本的数据类型
《深度优先、广度优先和A*算法实现的重排九宫问题》*********************************************************
*/


《深度优先、广度优先和A*算法实现的重排九宫问题》
《深度优先、广度优先和A*算法实现的重排九宫问题》
《深度优先、广度优先和A*算法实现的重排九宫问题》

#define
 DATATYPE int    
//
定义数据类型

《深度优先、广度优先和A*算法实现的重排九宫问题》

#define
 LINE    3        
//
矩阵的行

《深度优先、广度优先和A*算法实现的重排九宫问题》

#define
 ROW        3        
//
矩阵的列

《深度优先、广度优先和A*算法实现的重排九宫问题》

#define
 DATASIZE    LINE*ROW    
//
矩阵的大小

《深度优先、广度优先和A*算法实现的重排九宫问题》
《深度优先、广度优先和A*算法实现的重排九宫问题》
《深度优先、广度优先和A*算法实现的重排九宫问题》《深度优先、广度优先和A*算法实现的重排九宫问题》

class
 Data

{        //存储在open和close表中的数据元素
《深度优先、广度优先和A*算法实现的重排九宫问题》
public:
《深度优先、广度优先和A*算法实现的重排九宫问题》    DATATYPE element[DATASIZE];    
//九宫图以矩阵的方式存放
《深度优先、广度优先和A*算法实现的重排九宫问题》
    Data *pid;            //记录close表中父亲节点的位置
《深度优先、广度优先和A*算法实现的重排九宫问题》
    Data *next,*pre;    //双向链表
《深度优先、广度优先和A*算法实现的重排九宫问题》
    int gx,hx;
《深度优先、广度优先和A*算法实现的重排九宫问题》}

;
《深度优先、广度优先和A*算法实现的重排九宫问题》
《深度优先、广度优先和A*算法实现的重排九宫问题》《深度优先、广度优先和A*算法实现的重排九宫问题》

class
 F

{
《深度优先、广度优先和A*算法实现的重排九宫问题》
public:
《深度优先、广度优先和A*算法实现的重排九宫问题》    
int gx,hx;
《深度优先、广度优先和A*算法实现的重排九宫问题》    Data 
*addr;
《深度优先、广度优先和A*算法实现的重排九宫问题》    F 
*next;
《深度优先、广度优先和A*算法实现的重排九宫问题》}

;
《深度优先、广度优先和A*算法实现的重排九宫问题》
《深度优先、广度优先和A*算法实现的重排九宫问题》《深度优先、广度优先和A*算法实现的重排九宫问题》

void
 showElement(
const
 DATATYPE 
*
dt)

{    //打印数据元素的信息
《深度优先、广度优先和A*算法实现的重排九宫问题》
    int i;
《深度优先、广度优先和A*算法实现的重排九宫问题》《深度优先、广度优先和A*算法实现的重排九宫问题》    
for(i=0;i<DATASIZE;i++){
《深度优先、广度优先和A*算法实现的重排九宫问题》        
if(i%LINE==0)    cout<<endl;
《深度优先、广度优先和A*算法实现的重排九宫问题》        cout
<<dt[i]<< ;
《深度优先、广度优先和A*算法实现的重排九宫问题》    }

《深度优先、广度优先和A*算法实现的重排九宫问题》    cout
<<endl;
《深度优先、广度优先和A*算法实现的重排九宫问题》}


《深度优先、广度优先和A*算法实现的重排九宫问题》
《深度优先、广度优先和A*算法实现的重排九宫问题》
《深度优先、广度优先和A*算法实现的重排九宫问题》DATATYPE s0[LINE][ROW],sg[LINE][ROW];

 

 

《深度优先、广度优先和A*算法实现的重排九宫问题》
《深度优先、广度优先和A*算法实现的重排九宫问题》
/**/
/*********************************************************************************
《深度优先、广度优先和A*算法实现的重排九宫问题》 * link.h
《深度优先、广度优先和A*算法实现的重排九宫问题》 * 定义链表类,用于A*算法中的open表
《深度优先、广度优先和A*算法实现的重排九宫问题》********************************************************************************
*/


《深度优先、广度优先和A*算法实现的重排九宫问题》
《深度优先、广度优先和A*算法实现的重排九宫问题》《深度优先、广度优先和A*算法实现的重排九宫问题》

class
 Link: 
public
 Queue

{    //链表类
《深度优先、广度优先和A*算法实现的重排九宫问题》
private:
《深度优先、广度优先和A*算法实现的重排九宫问题》    Data head;
《深度优先、广度优先和A*算法实现的重排九宫问题》    F fhead;        
//估价函数临时表
《深度优先、广度优先和A*算法实现的重排九宫问题》
    int len;
《深度优先、广度优先和A*算法实现的重排九宫问题》
public:
《深度优先、广度优先和A*算法实现的重排九宫问题》    
void init();    //链表初始化
《深度优先、广度优先和A*算法实现的重排九宫问题》
    void show();    //显示链表
《深度优先、广度优先和A*算法实现的重排九宫问题》
    void push(DATATYPE *,Data **);    //数据入队
《深度优先、广度优先和A*算法实现的重排九宫问题》
    void pop(DATATYPE *,Data **);    //数据出队
《深度优先、广度优先和A*算法实现的重排九宫问题》
}

;    
《深度优先、广度优先和A*算法实现的重排九宫问题》
《深度优先、广度优先和A*算法实现的重排九宫问题》
《深度优先、广度优先和A*算法实现的重排九宫问题》《深度优先、广度优先和A*算法实现的重排九宫问题》

void
 Link::show()

{
《深度优先、广度优先和A*算法实现的重排九宫问题》    
if(empty()==true)    cout<<nothing to print, Link is empty<<endl;
《深度优先、广度优先和A*算法实现的重排九宫问题》    
else cout<<there are <<len<< members in the Link: <<endl;
《深度优先、广度优先和A*算法实现的重排九宫问题》    Data 
*temp=head.next;
《深度优先、广度优先和A*算法实现的重排九宫问题》《深度优先、广度优先和A*算法实现的重排九宫问题》    
while(temp){
《深度优先、广度优先和A*算法实现的重排九宫问题》        cout
<<f(x)=<<temp->gx+temp->hx<<endl;
《深度优先、广度优先和A*算法实现的重排九宫问题》        showElement(temp
->element);
《深度优先、广度优先和A*算法实现的重排九宫问题》        temp
=temp->next;
《深度优先、广度优先和A*算法实现的重排九宫问题》    }

《深度优先、广度优先和A*算法实现的重排九宫问题》}


《深度优先、广度优先和A*算法实现的重排九宫问题》
《深度优先、广度优先和A*算法实现的重排九宫问题》
《深度优先、广度优先和A*算法实现的重排九宫问题》
《深度优先、广度优先和A*算法实现的重排九宫问题》
《深度优先、广度优先和A*算法实现的重排九宫问题》《深度优先、广度优先和A*算法实现的重排九宫问题》

void
 Link::init()

{
《深度优先、广度优先和A*算法实现的重排九宫问题》    head.next
=head.pid=head.pre=NULL;
《深度优先、广度优先和A*算法实现的重排九宫问题》    fhead.next
=NULL;
《深度优先、广度优先和A*算法实现的重排九宫问题》    len
=0;
《深度优先、广度优先和A*算法实现的重排九宫问题》}


《深度优先、广度优先和A*算法实现的重排九宫问题》
《深度优先、广度优先和A*算法实现的重排九宫问题》
《深度优先、广度优先和A*算法实现的重排九宫问题》
《深度优先、广度优先和A*算法实现的重排九宫问题》
《深度优先、广度优先和A*算法实现的重排九宫问题》《深度优先、广度优先和A*算法实现的重排九宫问题》

void
 Link::pop(DATATYPE 
*
dt,Data 
**
pid)

{
《深度优先、广度优先和A*算法实现的重排九宫问题》《深度优先、广度优先和A*算法实现的重排九宫问题》    
if(empty()==true)    {
《深度优先、广度优先和A*算法实现的重排九宫问题》        cout
<<warning: pop Link error beacuse of can not pop a empty Link anykey to exit<<endl;
《深度优先、广度优先和A*算法实现的重排九宫问题》        getchar();
《深度优先、广度优先和A*算法实现的重排九宫问题》        exit(
1);
《深度优先、广度优先和A*算法实现的重排九宫问题》    }

《深度优先、广度优先和A*算法实现的重排九宫问题》    Data 
*temp=head.next;
《深度优先、广度优先和A*算法实现的重排九宫问题》    F 
*ftemp;
《深度优先、广度优先和A*算法实现的重排九宫问题》    ftemp
=new F;
《深度优先、广度优先和A*算法实现的重排九宫问题》    ftemp
->gx=temp->gx;
《深度优先、广度优先和A*算法实现的重排九宫问题》    ftemp
->hx=temp->hx;
《深度优先、广度优先和A*算法实现的重排九宫问题》    ftemp
->addr=temp->pid;
《深度优先、广度优先和A*算法实现的重排九宫问题》    ftemp
->next=fhead.next;
《深度优先、广度优先和A*算法实现的重排九宫问题》    fhead.next
=ftemp;
《深度优先、广度优先和A*算法实现的重排九宫问题》    memcpy(dt,temp
->element,DATASIZE*sizeof(DATATYPE));
《深度优先、广度优先和A*算法实现的重排九宫问题》    
*pid=temp->pid;
《深度优先、广度优先和A*算法实现的重排九宫问题》    head.next
=temp->next;
《深度优先、广度优先和A*算法实现的重排九宫问题》    
if(head.next)    head.next->pre=&head;
《深度优先、广度优先和A*算法实现的重排九宫问题》    delete temp;
《深度优先、广度优先和A*算法实现的重排九宫问题》    len
;
《深度优先、广度优先和A*算法实现的重排九宫问题》}


《深度优先、广度优先和A*算法实现的重排九宫问题》
《深度优先、广度优先和A*算法实现的重排九宫问题》
《深度优先、广度优先和A*算法实现的重排九宫问题》
《深度优先、广度优先和A*算法实现的重排九宫问题》《深度优先、广度优先和A*算法实现的重排九宫问题》

void
 Link::push(DATATYPE 
*
dt,Data 
**
pid)

{
《深度优先、广度优先和A*算法实现的重排九宫问题》    
int gx,hx;
《深度优先、广度优先和A*算法实现的重排九宫问题》    
int n,m,k;
《深度优先、广度优先和A*算法实现的重排九宫问题》    Data 
*temp,*loc;    
《深度优先、广度优先和A*算法实现的重排九宫问题》    F 
*ftemp;
《深度优先、广度优先和A*算法实现的重排九宫问题》    hx
=k=0;
《深度优先、广度优先和A*算法实现的重排九宫问题》《深度优先、广度优先和A*算法实现的重排九宫问题》    
/**//************************* 计算启发函数 h(x)    **************************/
《深度优先、广度优先和A*算法实现的重排九宫问题》    
for(n=0;n<LINE;n++)        
《深度优先、广度优先和A*算法实现的重排九宫问题》        
for(m=0;m<ROW;m++)
《深度优先、广度优先和A*算法实现的重排九宫问题》            
if(dt[k++]!=sg[n][m]) hx++;
《深度优先、广度优先和A*算法实现的重排九宫问题》《深度优先、广度优先和A*算法实现的重排九宫问题》    
/**//************************* 计算 g(x) ************************************/
《深度优先、广度优先和A*算法实现的重排九宫问题》《深度优先、广度优先和A*算法实现的重排九宫问题》    
if(fhead.next!=NULL){    //fhead表中存在数据
《深度优先、广度优先和A*算法实现的重排九宫问题》
        for(ftemp=fhead.next;ftemp;ftemp=ftemp->next)
《深度优先、广度优先和A*算法实现的重排九宫问题》《深度优先、广度优先和A*算法实现的重排九宫问题》            
if(ftemp->addr=*pid){
《深度优先、广度优先和A*算法实现的重排九宫问题》                gx
=ftemp->gx+1;
《深度优先、广度优先和A*算法实现的重排九宫问题》                
break;
《深度优先、广度优先和A*算法实现的重排九宫问题》            }

《深度优先、广度优先和A*算法实现的重排九宫问题》《深度优先、广度优先和A*算法实现的重排九宫问题》            
if(ftemp==NULL)    {
《深度优先、广度优先和A*算法实现的重排九宫问题》                puts(
can not caculate function g(x), program will exit);
《深度优先、广度优先和A*算法实现的重排九宫问题》                exit(
1);
《深度优先、广度优先和A*算法实现的重排九宫问题》            }

《深度优先、广度优先和A*算法实现的重排九宫问题》    }

《深度优先、广度优先和A*算法实现的重排九宫问题》《深度优先、广度优先和A*算法实现的重排九宫问题》    
else{    //fhead表为空
《深度优先、广度优先和A*算法实现的重排九宫问题》
        gx=0;    //根节点
《深度优先、广度优先和A*算法实现的重排九宫问题》
    }

《深度优先、广度优先和A*算法实现的重排九宫问题》《深度优先、广度优先和A*算法实现的重排九宫问题》    
/**//******************************创建新数据********************************/
《深度优先、广度优先和A*算法实现的重排九宫问题》    temp
=new Data;    
《深度优先、广度优先和A*算法实现的重排九宫问题》    memcpy(temp
->element,dt,DATASIZE*sizeof(DATATYPE));        //将dt复制给temp
《深度优先、广度优先和A*算法实现的重排九宫问题》
    temp->gx=gx;            
《深度优先、广度优先和A*算法实现的重排九宫问题》    temp
->hx=hx;
《深度优先、广度优先和A*算法实现的重排九宫问题》    
if(pid!=NULL)    temp->pid=*pid;
《深度优先、广度优先和A*算法实现的重排九宫问题》    
else temp->pid=NULL;
《深度优先、广度优先和A*算法实现的重排九宫问题》    temp
->pre=temp->next=NULL;
《深度优先、广度优先和A*算法实现的重排九宫问题》《深度优先、广度优先和A*算法实现的重排九宫问题》    
/**//******************************将数据添加到链表中**********************/
《深度优先、广度优先和A*算法实现的重排九宫问题》《深度优先、广度优先和A*算法实现的重排九宫问题》    
if(head.next==NULL){    //链表为空
《深度优先、广度优先和A*算法实现的重排九宫问题》
        head.next=temp;
《深度优先、广度优先和A*算法实现的重排九宫问题》        temp
->pre=&head;
《深度优先、广度优先和A*算法实现的重排九宫问题》        temp
->next=NULL;
《深度优先、广度优先和A*算法实现的重排九宫问题》        
++len;
《深度优先、广度优先和A*算法实现的重排九宫问题》        
return    ;
《深度优先、广度优先和A*算法实现的重排九宫问题》    }

《深度优先、广度优先和A*算法实现的重排九宫问题》《深度优先、广度优先和A*算法实现的重排九宫问题》    
else{    //链表不空
《深度优先、广度优先和A*算法实现的重排九宫问题》
        loc=head.next;
《深度优先、广度优先和A*算法实现的重排九宫问题》《深度优先、广度优先和A*算法实现的重排九宫问题》        
while(1){
《深度优先、广度优先和A*算法实现的重排九宫问题》《深度优先、广度优先和A*算法实现的重排九宫问题》            
if((temp->gx+temp->hx)<=(loc->gx+loc->hx)){
《深度优先、广度优先和A*算法实现的重排九宫问题》                loc
->pre->next=temp;
《深度优先、广度优先和A*算法实现的重排九宫问题》                temp
->pre=loc->pre;
《深度优先、广度优先和A*算法实现的重排九宫问题》                temp
->next=loc;
《深度优先、广度优先和A*算法实现的重排九宫问题》                loc
->pre=temp;
《深度优先、广度优先和A*算法实现的重排九宫问题》                
++len;
《深度优先、广度优先和A*算法实现的重排九宫问题》                
return;
《深度优先、广度优先和A*算法实现的重排九宫问题》            }

《深度优先、广度优先和A*算法实现的重排九宫问题》《深度优先、广度优先和A*算法实现的重排九宫问题》            
else if(loc->next==NULL){
《深度优先、广度优先和A*算法实现的重排九宫问题》                loc
->next=temp;
《深度优先、广度优先和A*算法实现的重排九宫问题》                temp
->next=NULL;
《深度优先、广度优先和A*算法实现的重排九宫问题》                temp
->pre=loc;
《深度优先、广度优先和A*算法实现的重排九宫问题》                
++len;
《深度优先、广度优先和A*算法实现的重排九宫问题》                
return;
《深度优先、广度优先和A*算法实现的重排九宫问题》            }

《深度优先、广度优先和A*算法实现的重排九宫问题》《深度优先、广度优先和A*算法实现的重排九宫问题》            
else{
《深度优先、广度优先和A*算法实现的重排九宫问题》                loc
=loc->next;
《深度优先、广度优先和A*算法实现的重排九宫问题》            }

《深度优先、广度优先和A*算法实现的重排九宫问题》        }

《深度优先、广度优先和A*算法实现的重排九宫问题》    }

《深度优先、广度优先和A*算法实现的重排九宫问题》}


《深度优先、广度优先和A*算法实现的重排九宫问题》
《深度优先、广度优先和A*算法实现的重排九宫问题》

 

 

《深度优先、广度优先和A*算法实现的重排九宫问题》
《深度优先、广度优先和A*算法实现的重排九宫问题》
/**/
/**************************************************************************
《深度优先、广度优先和A*算法实现的重排九宫问题》 * queue.h
《深度优先、广度优先和A*算法实现的重排九宫问题》 * 定义队列类,用广度优先的open表
《深度优先、广度优先和A*算法实现的重排九宫问题》*************************************************************************
*/


《深度优先、广度优先和A*算法实现的重排九宫问题》
《深度优先、广度优先和A*算法实现的重排九宫问题》《深度优先、广度优先和A*算法实现的重排九宫问题》

class
 Queue: 
private
 Data

{    //队列类
《深度优先、广度优先和A*算法实现的重排九宫问题》
private:
《深度优先、广度优先和A*算法实现的重排九宫问题》    Data head,
*loc;
《深度优先、广度优先和A*算法实现的重排九宫问题》    
int len;
《深度优先、广度优先和A*算法实现的重排九宫问题》
public:
《深度优先、广度优先和A*算法实现的重排九宫问题》    
int length();    //返回队列的长度
《深度优先、广度优先和A*算法实现的重排九宫问题》
    void init();    //队列初始化
《深度优先、广度优先和A*算法实现的重排九宫问题》
    bool empty();    //判断队列是否为空
《深度优先、广度优先和A*算法实现的重排九宫问题》
    void show();    //显示队列
《深度优先、广度优先和A*算法实现的重排九宫问题》
    bool exist(DATATYPE *);        //判断数据是否之前已经在队列中出现过
《深度优先、广度优先和A*算法实现的重排九宫问题》
    void push(DATATYPE *,Data **);    //数据入队
《深度优先、广度优先和A*算法实现的重排九宫问题》
    void pop(DATATYPE *,Data **);    //数据出队
《深度优先、广度优先和A*算法实现的重排九宫问题》
    Data * getTop(DATATYPE *);    //返回队头元素
《深度优先、广度优先和A*算法实现的重排九宫问题》
}

;
《深度优先、广度优先和A*算法实现的重排九宫问题》
《深度优先、广度优先和A*算法实现的重排九宫问题》
《深度优先、广度优先和A*算法实现的重排九宫问题》《深度优先、广度优先和A*算法实现的重排九宫问题》

void
 Queue::show()

{
《深度优先、广度优先和A*算法实现的重排九宫问题》    
if(empty()==true)    cout<<nothing to print, queue is empty<<endl;
《深度优先、广度优先和A*算法实现的重排九宫问题》    
else cout<<there are <<len<< members in the queue: <<endl;
《深度优先、广度优先和A*算法实现的重排九宫问题》    Data 
*temp=head.next;
《深度优先、广度优先和A*算法实现的重排九宫问题》《深度优先、广度优先和A*算法实现的重排九宫问题》    
while(temp){
《深度优先、广度优先和A*算法实现的重排九宫问题》        showElement(temp
->element);
《深度优先、广度优先和A*算法实现的重排九宫问题》        temp
=temp->next;
《深度优先、广度优先和A*算法实现的重排九宫问题》    }

《深度优先、广度优先和A*算法实现的重排九宫问题》}


《深度优先、广度优先和A*算法实现的重排九宫问题》
《深度优先、广度优先和A*算法实现的重排九宫问题》
《深度优先、广度优先和A*算法实现的重排九宫问题》《深度优先、广度优先和A*算法实现的重排九宫问题》

bool
 Queue::exist(DATATYPE 
*
dt)

{
《深度优先、广度优先和A*算法实现的重排九宫问题》    Data 
*temp=head.next;
《深度优先、广度优先和A*算法实现的重排九宫问题》《深度优先、广度优先和A*算法实现的重排九宫问题》    
while(temp){
《深度优先、广度优先和A*算法实现的重排九宫问题》        
if(memcmp(dt,temp->element,DATASIZE*sizeof(DATATYPE))==0)    return true;
《深度优先、广度优先和A*算法实现的重排九宫问题》        temp
=temp->next;
《深度优先、广度优先和A*算法实现的重排九宫问题》    }

《深度优先、广度优先和A*算法实现的重排九宫问题》    
return false;
《深度优先、广度优先和A*算法实现的重排九宫问题》}


《深度优先、广度优先和A*算法实现的重排九宫问题》
《深度优先、广度优先和A*算法实现的重排九宫问题》《深度优先、广度优先和A*算法实现的重排九宫问题》Data 

*
 Queue::getTop(DATATYPE 
*
dt)

{
《深度优先、广度优先和A*算法实现的重排九宫问题》    memcpy(dt,head.next
->element,DATASIZE*sizeof(DATATYPE));
《深度优先、广度优先和A*算法实现的重排九宫问题》    
return head.next;
《深度优先、广度优先和A*算法实现的重排九宫问题》}


《深度优先、广度优先和A*算法实现的重排九宫问题》
《深度优先、广度优先和A*算法实现的重排九宫问题》《深度优先、广度优先和A*算法实现的重排九宫问题》

void
 Queue::pop(DATATYPE 
*
dt,Data 
**
pid)

{
《深度优先、广度优先和A*算法实现的重排九宫问题》《深度优先、广度优先和A*算法实现的重排九宫问题》    
if(empty()==true)    {
《深度优先、广度优先和A*算法实现的重排九宫问题》        cout
<<warning: pop queue error beacuse of can not pop a empty queue anykey to exit<<endl;
《深度优先、广度优先和A*算法实现的重排九宫问题》        getchar();
《深度优先、广度优先和A*算法实现的重排九宫问题》        exit(
1);
《深度优先、广度优先和A*算法实现的重排九宫问题》    }

《深度优先、广度优先和A*算法实现的重排九宫问题》    Data 
*temp=head.next;
《深度优先、广度优先和A*算法实现的重排九宫问题》    memcpy(dt,temp
->element,DATASIZE*sizeof(DATATYPE));
《深度优先、广度优先和A*算法实现的重排九宫问题》    
*pid=temp->pid;
《深度优先、广度优先和A*算法实现的重排九宫问题》    head.next
=temp->next;
《深度优先、广度优先和A*算法实现的重排九宫问题》    
if(head.next)    head.next->pre=&head;
《深度优先、广度优先和A*算法实现的重排九宫问题》    delete temp;
《深度优先、广度优先和A*算法实现的重排九宫问题》    len
;
《深度优先、广度优先和A*算法实现的重排九宫问题》    
if(len==0)    loc=&head;
《深度优先、广度优先和A*算法实现的重排九宫问题》}


《深度优先、广度优先和A*算法实现的重排九宫问题》
《深度优先、广度优先和A*算法实现的重排九宫问题》《深度优先、广度优先和A*算法实现的重排九宫问题》

void
 Queue::push(DATATYPE 
*
dt,Data 
**
pid)

{
《深度优先、广度优先和A*算法实现的重排九宫问题》    Data 
*temp=loc;
《深度优先、广度优先和A*算法实现的重排九宫问题》    loc
=loc->next=new Data;
《深度优先、广度优先和A*算法实现的重排九宫问题》    memcpy(loc
->element,dt,DATASIZE*sizeof(DATATYPE));
《深度优先、广度优先和A*算法实现的重排九宫问题》    
if(pid!=NULL)    loc->pid=*pid;
《深度优先、广度优先和A*算法实现的重排九宫问题》    
else loc->pid=NULL;
《深度优先、广度优先和A*算法实现的重排九宫问题》    loc
->next=NULL;
《深度优先、广度优先和A*算法实现的重排九宫问题》    loc
->pre=temp;
《深度优先、广度优先和A*算法实现的重排九宫问题》    len
++;
《深度优先、广度优先和A*算法实现的重排九宫问题》}


《深度优先、广度优先和A*算法实现的重排九宫问题》
《深度优先、广度优先和A*算法实现的重排九宫问题》《深度优先、广度优先和A*算法实现的重排九宫问题》

void
 Queue::init()

{
《深度优先、广度优先和A*算法实现的重排九宫问题》    head.next
=head.pid=head.pre=NULL;
《深度优先、广度优先和A*算法实现的重排九宫问题》    loc
=&head;
《深度优先、广度优先和A*算法实现的重排九宫问题》    len
=0;
《深度优先、广度优先和A*算法实现的重排九宫问题》}


《深度优先、广度优先和A*算法实现的重排九宫问题》
《深度优先、广度优先和A*算法实现的重排九宫问题》《深度优先、广度优先和A*算法实现的重排九宫问题》

bool
 Queue::empty()

{
《深度优先、广度优先和A*算法实现的重排九宫问题》    
return len==0? true:false;
《深度优先、广度优先和A*算法实现的重排九宫问题》}


《深度优先、广度优先和A*算法实现的重排九宫问题》
《深度优先、广度优先和A*算法实现的重排九宫问题》《深度优先、广度优先和A*算法实现的重排九宫问题》

int
 Queue::length()

{
《深度优先、广度优先和A*算法实现的重排九宫问题》    
return len;
《深度优先、广度优先和A*算法实现的重排九宫问题》}

 

 

《深度优先、广度优先和A*算法实现的重排九宫问题》
《深度优先、广度优先和A*算法实现的重排九宫问题》
/**/
/*********************************************************************************
《深度优先、广度优先和A*算法实现的重排九宫问题》 * stack.h
《深度优先、广度优先和A*算法实现的重排九宫问题》 * 定义栈类,用于三种算法的close表以及深度优先搜索的open表
《深度优先、广度优先和A*算法实现的重排九宫问题》**********************************************************************************
*/


《深度优先、广度优先和A*算法实现的重排九宫问题》
《深度优先、广度优先和A*算法实现的重排九宫问题》《深度优先、广度优先和A*算法实现的重排九宫问题》

class
 Stack

{    //栈类
《深度优先、广度优先和A*算法实现的重排九宫问题》
private:
《深度优先、广度优先和A*算法实现的重排九宫问题》    Data head,
*loc;
《深度优先、广度优先和A*算法实现的重排九宫问题》    
int len;
《深度优先、广度优先和A*算法实现的重排九宫问题》
public:
《深度优先、广度优先和A*算法实现的重排九宫问题》    
void init();    //初始化栈
《深度优先、广度优先和A*算法实现的重排九宫问题》
    int length();    //返回栈的长度
《深度优先、广度优先和A*算法实现的重排九宫问题》
    bool empty();    //判断栈是否为空
《深度优先、广度优先和A*算法实现的重排九宫问题》
    void show();    //显示栈
《深度优先、广度优先和A*算法实现的重排九宫问题》
    bool exist(DATATYPE *dt);    //判断元素是否在栈中已经出现过
《深度优先、广度优先和A*算法实现的重排九宫问题》
    void push(DATATYPE *,Data **);    //数据入栈
《深度优先、广度优先和A*算法实现的重排九宫问题》
    void pop(DATATYPE *,Data **);    //数据出栈
《深度优先、广度优先和A*算法实现的重排九宫问题》
    Data * getTop(DATATYPE *);        //返回栈顶元素
《深度优先、广度优先和A*算法实现的重排九宫问题》
}

;
《深度优先、广度优先和A*算法实现的重排九宫问题》
《深度优先、广度优先和A*算法实现的重排九宫问题》《深度优先、广度优先和A*算法实现的重排九宫问题》

void
 Stack::show()

{
《深度优先、广度优先和A*算法实现的重排九宫问题》    
if(empty()==true)    cout<<stack is emtpy <<endl;
《深度优先、广度优先和A*算法实现的重排九宫问题》    
else    cout<<there are <<len<< members in the stack<<endl;
《深度优先、广度优先和A*算法实现的重排九宫问题》    Data 
*temp=loc;
《深度优先、广度优先和A*算法实现的重排九宫问题》    
int i=0;
《深度优先、广度优先和A*算法实现的重排九宫问题》《深度优先、广度优先和A*算法实现的重排九宫问题》    
while(temp){
《深度优先、广度优先和A*算法实现的重排九宫问题》        cout
<<step <<i++<< :<<endl;
《深度优先、广度优先和A*算法实现的重排九宫问题》        showElement(temp
->element);
《深度优先、广度优先和A*算法实现的重排九宫问题》        temp
=temp->pid;
《深度优先、广度优先和A*算法实现的重排九宫问题》    }

《深度优先、广度优先和A*算法实现的重排九宫问题》}


《深度优先、广度优先和A*算法实现的重排九宫问题》
《深度优先、广度优先和A*算法实现的重排九宫问题》
《深度优先、广度优先和A*算法实现的重排九宫问题》《深度优先、广度优先和A*算法实现的重排九宫问题》

bool
 Stack::exist(DATATYPE 
*
dt)

{
《深度优先、广度优先和A*算法实现的重排九宫问题》    Data 
*temp=head.next;
《深度优先、广度优先和A*算法实现的重排九宫问题》《深度优先、广度优先和A*算法实现的重排九宫问题》    
while(temp){
《深度优先、广度优先和A*算法实现的重排九宫问题》        
if(memcmp(temp->element,dt,DATASIZE*sizeof(DATATYPE))==0)    return true;
《深度优先、广度优先和A*算法实现的重排九宫问题》        temp
=temp->next;
《深度优先、广度优先和A*算法实现的重排九宫问题》    }

《深度优先、广度优先和A*算法实现的重排九宫问题》    
return false;
《深度优先、广度优先和A*算法实现的重排九宫问题》}


《深度优先、广度优先和A*算法实现的重排九宫问题》
《深度优先、广度优先和A*算法实现的重排九宫问题》《深度优先、广度优先和A*算法实现的重排九宫问题》Data 

*
Stack::getTop(DATATYPE 
*
dt)

{
《深度优先、广度优先和A*算法实现的重排九宫问题》    memcpy(dt,loc
->element,DATASIZE*sizeof(DATATYPE));
《深度优先、广度优先和A*算法实现的重排九宫问题》    
return loc;
《深度优先、广度优先和A*算法实现的重排九宫问题》}


《深度优先、广度优先和A*算法实现的重排九宫问题》
《深度优先、广度优先和A*算法实现的重排九宫问题》《深度优先、广度优先和A*算法实现的重排九宫问题》

void
 Stack::pop(DATATYPE 
*
dt,Data 
**
pid)

{
《深度优先、广度优先和A*算法实现的重排九宫问题》《深度优先、广度优先和A*算法实现的重排九宫问题》    
if(empty()==true){
《深度优先、广度优先和A*算法实现的重排九宫问题》        cout
<<warning: pop stack error beacuse of stack is empty anykey to exit<<endl;
《深度优先、广度优先和A*算法实现的重排九宫问题》        getchar();
《深度优先、广度优先和A*算法实现的重排九宫问题》        exit(
1);
《深度优先、广度优先和A*算法实现的重排九宫问题》    }

《深度优先、广度优先和A*算法实现的重排九宫问题》    Data 
*temp=loc;
《深度优先、广度优先和A*算法实现的重排九宫问题》    loc
=loc->pre;
《深度优先、广度优先和A*算法实现的重排九宫问题》    loc
->next=NULL;
《深度优先、广度优先和A*算法实现的重排九宫问题》    memcpy(dt,temp
->element,DATASIZE*sizeof(DATATYPE));
《深度优先、广度优先和A*算法实现的重排九宫问题》    
*pid=temp->pid;
《深度优先、广度优先和A*算法实现的重排九宫问题》    delete temp;
《深度优先、广度优先和A*算法实现的重排九宫问题》    len
;
《深度优先、广度优先和A*算法实现的重排九宫问题》}


《深度优先、广度优先和A*算法实现的重排九宫问题》
《深度优先、广度优先和A*算法实现的重排九宫问题》《深度优先、广度优先和A*算法实现的重排九宫问题》

void
 Stack::push(DATATYPE 
*
dt,Data 
**
pid)

{
《深度优先、广度优先和A*算法实现的重排九宫问题》    Data 
*temp=loc;
《深度优先、广度优先和A*算法实现的重排九宫问题》    loc
=loc->next=new Data;
《深度优先、广度优先和A*算法实现的重排九宫问题》    memcpy(loc
->element,dt,DATASIZE*sizeof(DATATYPE));
《深度优先、广度优先和A*算法实现的重排九宫问题》    
if(pid!=NULL)    loc->pid=*pid;
《深度优先、广度优先和A*算法实现的重排九宫问题》    
else loc->pid=NULL;
《深度优先、广度优先和A*算法实现的重排九宫问题》    loc
->next=NULL;
《深度优先、广度优先和A*算法实现的重排九宫问题》    loc
->pre=temp;
《深度优先、广度优先和A*算法实现的重排九宫问题》    len
++;
《深度优先、广度优先和A*算法实现的重排九宫问题》}


《深度优先、广度优先和A*算法实现的重排九宫问题》
《深度优先、广度优先和A*算法实现的重排九宫问题》《深度优先、广度优先和A*算法实现的重排九宫问题》

void
 Stack::init()

{
《深度优先、广度优先和A*算法实现的重排九宫问题》    head.next
=head.pid=head.pre=NULL;
《深度优先、广度优先和A*算法实现的重排九宫问题》    loc
=&head;
《深度优先、广度优先和A*算法实现的重排九宫问题》    len
=0;
《深度优先、广度优先和A*算法实现的重排九宫问题》}


《深度优先、广度优先和A*算法实现的重排九宫问题》
《深度优先、广度优先和A*算法实现的重排九宫问题》《深度优先、广度优先和A*算法实现的重排九宫问题》

int
 Stack::length()

{
《深度优先、广度优先和A*算法实现的重排九宫问题》    
return len;
《深度优先、广度优先和A*算法实现的重排九宫问题》}


《深度优先、广度优先和A*算法实现的重排九宫问题》
《深度优先、广度优先和A*算法实现的重排九宫问题》《深度优先、广度优先和A*算法实现的重排九宫问题》

bool
 Stack::empty()

{
《深度优先、广度优先和A*算法实现的重排九宫问题》    
return len==0? true:false;
《深度优先、广度优先和A*算法实现的重排九宫问题》}

    原文作者:九宫格问题
    原文地址: https://blog.csdn.net/befun/article/details/1820395
    本文转自网络文章,转载此文章仅为分享知识,如有侵权,请联系博主进行删除。
点赞