难道代码有错？ 我自己都忍受不了了

代码是完全正确的了，

参照了下图，对比数组前28项值，是一样的


这图说明偶的代码还能优化， 判断的不够及时


[ 本帖最后由 BlueGuy 于 2011-1-24 21:17 编辑 ]

#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;

typedef struct bgStack
{
    Matrix* data;
    int top;
}BGStack;
typedef BGStack* Stack;

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

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

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

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

int cnt = -1;

Queue queue;

Stack stack;

FILE* log;

void bfs(Matrix matrix);

void initQueue(int length);

void putQueue(Matrix matrix);

Matrix getQueue(void);

int isQueueEmpty(void);

int isQueueFull(void);

void initStack(int length);

void pushStack(Matrix matrix);

Matrix popStack(void);

int isStackEmpty(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(3628800);
    initStack(1000);
   
    src.v = 2;
    src.w = 2;
    matrixCpy(src.matrix, srcMatrix);
    src.pre = cnt;
   
    bfs(src);
   
    bgCloseLog();
   
    getchar();
   
    return 0;
}

void bfs(Matrix matrix)
{
    Matrix t, s;
   
    int v, w;
   
    int direction, tmp;
   
    putQueue(matrix);
   
    while (!isQueueEmpty())
    {
        s = getQueue();
        
        cnt++;
        
        for (direction = 0; direction < 4; direction++)
        {
            t = s;
            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;
               
                for (tmp = 0; tmp < queue->tail; tmp++)
                {
                    if (matrixCmp(queue->data[tmp].matrix, t.matrix))
                    {
                        break;
                    }
                }

                if (tmp == queue->tail)
                {
                    putQueue(t);
                    
                    if (matrixCmp(t.matrix, dstMatrix))
                    {
                        pushStack(t);
                        
                        for (tmp = t.pre; !matrixCmp(queue->data[tmp].matrix, srcMatrix); tmp = queue->data[tmp].pre)
                        {
                            pushStack(queue->data[tmp]);
                        }
                        
                        matrixCpy(t.matrix, srcMatrix);
                        pushStack(t);
                        
                        while (!isStackEmpty())
                        {
                            s = popStack();
                            matrixPrint(s.matrix);
                        }
                        
                        printf("Hi, BlueGuy");

                        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;
}

void initStack(int length)
{
    stack = malloc(sizeof(BGStack));
   
    stack->data = malloc(sizeof(Matrix) * length);
    stack->top = 0;
   
}

void pushStack(Matrix matrix)
{
   
    stack->data[stack->top++] = matrix;
}

Matrix popStack(void)
{
    Matrix ret;
    ret = stack->data[--stack->top];
   
    return ret;
}

int isStackEmpty(void)
{
    return (stack->top == 0);
}



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;
}

一个节点都不多余~~~

                            很久没来了   
                                                来冒个泡0.0

建议你不要用for逐一判断，最好用系统函数

看到这里我就特鄙视楼主，叫人提意见，还说别人sb？

而且你这个在tc里可以运行，但在vc里就不行了。malloc都没转换

话说
建议大家还是把讨论重点放在代码上。。。

。。。。。耐心有啊，我盯着看了4分钟呢

告诉你一个小技巧， malloc 不需要转换的

经过我简单分析，发现八数码 和那个 迷宫寻路 是一模一样的问题，
我很少做题目，正好拿 八数码 小试牛刀一下，验证形式化的理论能不能
很好的解决实际问题。
通过这份代码，使我更深刻的理解了 bfs 的改进版本。

我在写这份代码之前就已经确信自己能够把代码写的完全正确，
而且我也不是抱着讨论或者学习的态度发帖的，所以别人提不提意见关系不是很大。
这份代码在形式上已经足够简单，本着低调的分享精神才帖出来求意见，求bug.

[ 本帖最后由 BlueGuy 于 2011-1-29 21:12 编辑 ]