不错啊。

我刚才也写了一个， 不过我只对4个方向搜索
h = f + g
// 结点初始化
void AStarNodeInit(AStartListNode* current, AStartListNode* father, int x, int y, int endX, int endY)
{
    current->x = x;
    current->y = y;
    current->father = father;
    current->next = NULL;

    if (father != NULL)
    {
        current->f = father->f + 1;
    }
    else
    {
        current->f = 0;
    }

    current->g = abs(endX - x) + abs(endY - y);
    current->h = current->f + current->g;
}

你在搜索8个方向的时候，写的繁琐了
int offsetX[] = { 0, -1, 0, 1 };
int offsetY[] = { -1, 0, 1, 0 };
            
for (i = 0; i < sizeof(offsetX); i++)
{
    x = current->x + offsetX[i];
    y = current->y + offsetY[i];

    if (x < 0 || x >= mapWidth || y < 0 || y >= mapHeight)
    {
        continue;
    }
}

代码的正确性可以保证，置顶一下，一起学习学习 laoyang 的代码.,

[ 本帖最后由 BlueGuy 于 2011-9-25 13:52 编辑 ]

其实， BFS（队列）, DFS（栈）, A*（优先队列） 搜索的时候，路径是定下来的，
每次运行程序得到的都是同一组解就能说明这一点。

我个人觉得随机队列 实现的搜索称为 "盲目搜索" 比较合适，
它真的是盲目, 人力不能确定结果.

我写的那个A*, 也是用 链表 模拟的 优先队列, 不过改名为 PriorityQueue更合适一点
队列、栈、优先队列、随机队列 记得是统称为广义队列的。

[ 本帖最后由 BlueGuy 于 2011-9-25 14:31 编辑 ]

顶，看看再说

楼主好人。。。

楼主好人。。。错的啊。。。错的啊、。

给点我吧

说实话，对这种看名字就恐怖的算法心理发憷啊，没信心去看

看不明白……

0.0