A*算法 机器人路径规划

机器人路径规划算法 经典算法 c语言实现的 啊啊

#include “Apath.h“

linkList InitList（）
{
    linkList L = （linkList）malloc（sizeof（LNode））;
    if （L == NULL）
    {
        printf（“Defeat!“）;
        exit（1）;
    }
    memset（L0sizeof（LNode））;
    return L;
}//linkList（）

LNode** malloc_array2D（int row int col）
{
    LNode** map = （LNode**）malloc（row*sizeof（LNode*） + row*col*sizeof（LNode））;
    LNode* head = （LNode*）（map + row）;
    for （int i = 0; i < row; ++i）
        map[i] = head + i*col;
    return map;
}

LNode** Translate_array（int array[][10] int row int col）
{
    LNode **map = malloc_array2D（10 10）;
    for （int i = 0; i < row; ++i）
        for （int j = 0; j < col; ++j）
        {
            （map[i] + j）->data = array[i][j];
            （map[i] + j）->G = 0;
            （map[i] + j）->H = 0;
            （map[i] + j）->F = 0;    //（map[i] + j）->G + （map[i] + j）->H;
            （map[i] + j）->x = i;
            （map[i] + j）->y = j;
            （map[i] + j）->Close_flag = 0;
            （map[i] + j）->OPen_flag = 0;
            （map[i] + j）->next = NULL;
            （map[i] + j）->path_next = NULL;
        }
    return map;
}//Translate_array（）

void free_array2D（LNode **arr）
{
    free（arr）;
}

void output（LNode** array int row int col）  //二维数组的访问必须指明位数，否则编译器不能解析
{
    //for （int i = 0; i < row; ++i）
    //    for （int j = 0; j < col; ++j）
    //    {
    //        （array[i] + j）->F = j;
    //    }
    for （int i = 0; i < row; ++i）
    {
        for （int j = 0; j < col; ++j）
        {
            printf（“%d\t“ （array[i] + j）->data）;
        }
        printf（“\n“）;
    }
}

LNode* find_start_LNode（LNode** Arr int row int col）    //从数组中找到始点
{
    LNode* start_LNode = NULL;
    for （int i = 0; i < row; ++i）
    {
        for （int j = 0; j < col; ++j）
        {
            if （2 == （Arr[i] + j）->data）
            {
                start_LNode = （Arr[i] + j）;
                //起点H=0G=0F=0
                start_LNode->G = 0;
                start_LNode->H = 0;
                start_LNode->F = 0;        //起点，则默认所有值为0
                return start_LNode;        //返回节点
            }
        }
    }
    return NULL;
}
LNode* find_end_LNode（LNode** Arr int row int col）        //从数组中找到终点
{
    LNode* end_LNode = NULL;
    for （int i = 0; i < row; ++i）
    {
        for （int j = 0; j < col; ++j）
        {
            if （3 == （Arr[i] + j）->data）
            {
                end_LNode = （*（Arr + i） + j）;
                end_LNode->F = 0;
                end_LNode->G = 0;
                end_LNode->H = 0;
                return end_LNode;        //返回节点
            }
        }
    }
    return NULL;
}

int count_LNode_G（LNode* curLNode LNode* aheadLNode）        //计算节点的G值
{
    if （curLNode->x == aheadLNode->y && curLNode->y == aheadLNode->y）
        return 0;
    if （aheadLNode->x - curLNode->x != 0 && aheadLNode->y - curLNode->y !=0）
        curLNode->G = aheadLNode->G + 14;
    el

 属性            大小     日期    时间   名称
----------- ---------  ---------- -----  ----

     文件       7004  2018-05-18 11:05  A算法\apath.c.cpp

     文件       2582  2018-05-18 11:08  A算法\apath.h

     文件       1854  2018-05-18 11:08  A算法\main.c

     目录          0  2018-05-18 11:07  A算法

----------- ---------  ---------- -----  ----

                11440                    4