我得去买票了，....

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

#define NUM 5

typedef struct bgMatrix
{
    int v, w;
    char matrix[NUM][NUM];
    int pre;
}Matrix;

typedef struct bgQueue
{
    Matrix* data;
    int maxLength;
    int head;
    int tail;
}BGQueue;
typedef BGQueue* Queue;


char srcMatrix[NUM][NUM] =
{
    {'*', '*', '*', '*', '*'},
    {'*', '1', '2', '3', '*'},
    {'*', '4', '5', '6', '*'},
    {'*', '7', '8', '0', '*'},
    {'*', '*', '*', '*', '*'}
};

char dstMatrix[NUM][NUM] =
{
    {'*', '*', '*', '*', '*'},
    {'*', '1', '2', '0', '*'},
    {'*', '4', '5', '3', '*'},
    {'*', '7', '8', '6', '*'},
    {'*', '*', '*', '*', '*'}
};

int dx[4] = {0, 0, -1, 1};

int dy[4] = {-1, 1, 0, 0};

int cnt = -1;

Queue queue;

FILE* log;

void bfs(Matrix matrix);

void initQueue(int length);

void putQueue(Matrix matrix);

Matrix getQueue(void);

int isQueueEmpty(void);

int isQueueFull(void);

int matrixCmp(char src[][NUM], char dst[][NUM]);

void matrixCpy(char dst[][NUM], char src[][NUM]);

void matrixPrint(char matrix[][NUM]);

void bgOpenLog(void);

void bgWriteLog(const char* s);

void bgCloseLog(void);

int main(void)
{
    Matrix src;
 
    bgOpenLog();

    initQueue(5200);
   
    src.v = 3;
    src.w = 3;
    matrixCpy(src.matrix, srcMatrix);
    src.pre = cnt;

    bfs(src);

    bgCloseLog();

    getchar();

    return 0;
}

void bfs(Matrix matrix)
{
    Matrix t;
   
    int v, w;
    int direction, tmp;

    putQueue(matrix);

    while (!isQueueEmpty())
    {
        t = getQueue();

        if (!matrixCmp(t.matrix, dstMatrix))
        {
            cnt++;

            for (direction = 0; direction < 4; direction++)
            {
                v = t.v + dx[direction]; w = t.w + dy[direction];

                if (srcMatrix[v][w] != '*')
                {
                    tmp = t.matrix[t.v][t.w];
                    t.matrix[t.v][t.w] = t.matrix[v][w];
                    t.matrix[v][w] = tmp;
                    
                    t.v = v;
                    t.w = w;
                    t.pre = cnt;

                    putQueue(t);
                }
            }
        }
        else
        {
            matrixPrint(t.matrix);

            for (tmp = t.pre; !matrixCmp(queue->data[tmp].matrix, srcMatrix); tmp = queue->data[tmp].pre)
            {
                matrixPrint(queue->data[tmp].matrix);
            }
            
            matrixPrint(srcMatrix);
            return;
        }
    }
}

void initQueue(int length)
{
    queue = malloc(sizeof(BGQueue));
   
    queue->data = malloc(sizeof(Matrix) * length);
    queue->maxLength = length;
    queue->head = 0;
    queue->tail = 0;
}

void putQueue(Matrix matrix)
{
    queue->data[queue->tail++] = matrix;
    queue->tail = queue->tail % queue->maxLength;
}

Matrix getQueue(void)
{
    Matrix ret;

    ret = queue->data[queue->head++];
    queue->head = queue->head % queue->maxLength;

    return ret;
}

int isQueueEmpty(void)
{
    return queue->head == queue->tail;
}

int isQueueFull(void)
{
    return ((queue->tail+1) % queue->maxLength) == queue->head;
}

int matrixCmp(char src[][NUM], char dst[][NUM])
{
    int i, j, s, t, ret;
   
    char srcString[30] = {0};
    char dstString[30] = {0};

    s = 0;
    t = 0;

    for (i = 0; i < NUM; i++)
    {
        for (j = 0; j < NUM; j++)
        {
            srcString[s++] = src[i][j];
            dstString[t++] = dst[i][j];
        }
    }

    ret = !strcmp(srcString, dstString);

    return ret;
}


void matrixCpy(char dst[][NUM], char src[][NUM])
{
    int i, j;

    for (i = 0; i < NUM; i++)
    {
        for (j = 0; j < NUM; j++)
        {
            dst[i][j] = src[i][j];
        }
    }
}

void matrixPrint(char matrix[][NUM])
{
    char logTxt[60] = {0};

    int i, j, k;

    k = 0;

    for (i = 0; i < NUM; i++)
    {
        for (j = 0; j < NUM; j++)
        {
            logTxt[k++] = matrix[i][j];
        }

        logTxt[k++] = '\r';
        logTxt[k++] = '\n';
    }
   
    logTxt[k++] = '\r';
    logTxt[k++] = '\n';

    bgWriteLog(logTxt);

}

void bgOpenLog(void)
{
    if(log == NULL)
    {
        log = fopen("log.txt", "wb");
    }
}

void bgWriteLog(const char* s)
{
    fwrite(s, sizeof(char), strlen(s), log);
}

void bgCloseLog(void)
{
    fclose(log);
    log = NULL;
}

不敢，不敢，我的水平还没到那个档次

感谢楼主，新人认真学习了，不过有些不怎么懂。

楼主为什么调试会发生错误呢？

楼主，那个malloc函数需要强制类型转换的

我怎么感觉你是在讽刺我，
从你楼下的那个SB的回帖，越发的证明了我的感觉是对的。/

代码长，算法慢。

楼上，一票难求。

谁喷粪让谁咽回去，

有胆量就写个不烂的代码我看看， 是不是有资格跟我叫板,