A*寻路算法c＋＋

最新推荐文章于 2023-11-07 00:07:22 发布
原创 最新推荐文章于 2023-11-07 00:07:22 发布 · 534 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文介绍了一种基于A*算法的路径寻找实现方法。该方法通过定义特定的数据结构和逻辑流程，在给定的二维网格环境中寻找从起点到终点的有效路径。文章详细描述了初始化路径、更新数据、排序节点等关键步骤，并展示了如何使用C++实现这一过程。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

//

//  Algorithm_A_Self.cpp

//  StudyTest

//

//  Created by metrics001 on 16/11/9.

//

//


#include "Algorithm_A_Self.hpp"

#define DIS  50

#define boardDIS  140

#define boardDIS2  260


static POSTION allPOSTION[25];

static const POINT* point_head;


static vector*> pointList;


void Algorithm_A_Self::init_path(Layer* layer)

{

    

    int data[5][5] = {

        {1,1,1,1,1},

        {1,1,1,0,1},

        {1,1,1,0,1},

        {1,0,0,1,1},

        {1,1,1,1,1}

    };

    int index = 0;

    int n =5;int m =5;

    for (int i =0;i

        for (int j =0;j

            allPOSTION[index].x = j;

            allPOSTION[index].y = i;

            allPOSTION[index].value = data[i][j];

            index++;

        }

    }

    for (int i = 0; i<</span>25; i++) {

        Sprite* spr = Sprite::create("CloseNormal.png");

        layer->addChild(spr);

        spr->setPosition(Vec2(boardDIS+allPOSTION[i].x*DIS,boardDIS2-allPOSTION[i].y*DIS));

        if (allPOSTION[i].value==0) {

            spr->setColor(Color3B(255,0,0));

        }

    }

    

}


int Algorithm_A_Self::get_length(POINT* cur)

{

    int length = 1;

    POINT* point = cur;

    while (point->m_last!=nullptr) {

        point = point->m_last;

        length++;

    }

    return length;

}



bool Algorithm_A_Self::check_pos_valid(POSTION pos)

{

    for (int i = 0; i<</span>25; i++) {

        if (pos.x == allPOSTION[i].x&&pos.y == allPOSTION[i].y) {

            if (allPOSTION[i].value==0) {

                return  false;

            }

            return true;

        }

    }

    return false;

}



void Algorithm_A_Self::handle_point(POINT* cur,POSTION pos,vector* nextList)

{

    

    POINT* point = check_bool_at_path(pos,point_head);

    if (point==nullptr) {

        POINT* pData = new POINT();

        pData->m_pos = pos;

        cur->m_next->push_back(pData);

        pData->m_last = cur;

        pData->m_length = get_length(pData);

        //新加的放入下次搜索列表中

        nextList->push_back(pData);

    }else

    {

        

        point->m_length = get_length(point);

        cur->m_length = get_length(cur);

        if (point->m_length >cur->m_length+1) {

            

            POINT* last = point->m_last;

            point->m_last = cur;

            cur->m_next->push_back(point);

            if (last==nullptr) {

                return;

            }

            

            vector<_POINT*>* next = last->m_next;

            int index = 0;

            for (auto iter = next->begin(); iter != next->end(); iter++) {

                

                if (*iter==point) {

                    next->erase(next->begin()+index);

                    break;

                }

                index++;

            }

        }

        

    }

    

}


vector* Algorithm_A_Self::updata_data_for_queue(vector* points)

{

    if(NULL == points )

        return nullptr;

    vector* nextList = new vector();

    

    for(int index = 0; index < points->size(); index ++){

        

        POINT* data = points->at(index);

        if ( data->m_open==false) {  //检测过了，有点远

            continue;

        }

        

        vector* pointList = new vector();

        data->m_next = pointList;

        if(check_pos_valid(POSTION(data->m_pos.x, data->m_pos.y - 1))){

            handle_point(data,POSTION(data->m_pos.x, data->m_pos.y - 1),nextList);

        }

        

        if(check_pos_valid(POSTION(data->m_pos.x -1, data->m_pos.y))){

            handle_point(data,POSTION(data->m_pos.x -1, data->m_pos.y),nextList);

        }

        

        if(check_pos_valid(POSTION(data->m_pos.x, data->m_pos.y + 1))){

            handle_point(data,POSTION(data->m_pos.x, data->m_pos.y + 1),nextList);

        }

        

        if(check_pos_valid(POSTION(data->m_pos.x + 1, data->m_pos.y))){

            handle_point(data,POSTION(data->m_pos.x + 1, data->m_pos.y),nextList);

        }

    }

//    points->clear();

//    delete points;

    return nextList;

}


POINT* Algorithm_A_Self::check_bool_at_path(POSTION pos,const POINT* head)

{

    const POINT* cur = head;

    if (cur->m_pos.x==pos.x&&cur->m_pos.y==pos.y) {

//        printf("已经存在了\n");

        return (POINT*)cur;

    }

    if (cur->m_next == nullptr || cur->m_next->size()==0) {

        return nullptr;

    }

    for (auto iter = cur->m_next->begin(); iter != cur->m_next->end(); iter++) {

        POINT* point =  check_bool_at_path(pos,*iter);

        if (point!=nullptr) {

             return point;

        }

    }

    return nullptr;

}


//    得到估算距离最近

POINT* Algorithm_A_Self::sort_most_nearest_neigh(vector* pointList,POSTION end)

{

    //排序优先查找最小的

    sort(pointList->begin(),pointList->end(),[=](POINT* p1,POINT* p2){

                int dis1 = abs(p1->m_pos.x - end.x)+ abs(p1->m_pos.y - end.y) + get_length(p1);

                int dis2 = abs(p2->m_pos.x - end.x)+ abs(p2->m_pos.y - end.y)+ get_length(p2);;

        

//        point->m_length = get_length(point);

//        cur->m_length = get_length(cur);

        

//        float dis1 = (float) sqrt((p1->m_pos.x - end.x) * (p1->m_pos.x - end.x)+ (p1->m_pos.y - end.y) *  (p1->m_pos.y - end.y));

//        float dis2 = (float) sqrt((p2->m_pos.x - end.x) * (p2->m_pos.x - end.x)+ (p2->m_pos.y - end.y) *  (p2->m_pos.y - end.y));

        if (dis1

            return true;

        }

        return false;

    });

    return pointList->at(0);

}

POINT* Algorithm_A_Self::check_path(POINT* point,POSTION end)

{

    

    vector* points = new vector();

    points->push_back(point);

    

    while (true) {

        if (points->size()==0) {

            printf("此路不通\n");

            return nullptr;

        }

        pointList.push_back(points);

        //    //排序下一级的点

        POINT* min = sort_most_nearest_neigh(points,end);

         //    //关闭远的点

        int dis1 = abs(min->m_pos.x - end.x)+ abs(min->m_pos.y - end.y) + get_length(min);

        for (int i = 0;isize(); i++) {

            POINT *point = points->at(i);

            int dis = abs(point->m_pos.x - end.x)+ abs(point->m_pos.y - end.y) + get_length(point);

            if (dis>dis1) {

                point->m_open=false;

                break;

            }

        }

        

        for (auto iter = points->begin(); iter != points->end(); iter++) {

            POINT* cur = *iter;

            if (cur->m_pos.x==end.x&&cur->m_pos.y==end.y) {

                printf("找到目标了\n");

                return cur;

            }

        }

    

        points = updata_data_for_queue(points);

        

        printf("count:%d\n",(int)points->size());

        

    }

    return nullptr;

    

    

//    POINT* cur = point;

//    if (cur->m_pos.x==end.x&&cur->m_pos.y==end.y) {

//        printf("找到目标了\n");

//        return cur;

//    }

//    vector* points = updata_data_for_queue(cur);

//    if (points->size()==0) {

//        

//        printf("此路不通\n");

//         printf("%d,%d,\n",cur->m_pos.x,cur->m_pos.y);

//        return nullptr;

//    }

//    

//    

//    //排序下一级的点

//   POINT* min = sort_most_nearest_neigh(points,end);

//    

//    for (auto iter = points->begin(); iter != points->end(); iter++) {

//        POINT* cur = *iter;

//        POINT* point =check_path(cur, end);

//        if (point!=nullptr) {

//            printf("找到目标了\n");

//            return point;

//        }

//    }

//    

////   return check_path(min,end);

//    

//    POINT* reult = nullptr;

//    for (auto iter = cur->m_next->begin(); iter != cur->m_next->end(); iter++) {

//        POINT* _reult = check_path(*iter,end);

//        if (_reult!=nullptr) {

//             return _reult;

////            reult =  _reult;

//        }

//    }

//    return reult;

}

void Algorithm_A_Self::find_path(POSTION begin,POSTION end,Layer* layer)

{


    POINT*head = new POINT();

    point_head = head;

    POINT*cur = head;

    cur->m_pos = begin;

    POINT* end_pint = check_path(cur,end);

    if (end_pint == nullptr) {

        printf("没有找到可行路径\n");

        return ;

    }

//    routePOSTION 即为路径

    POINT* point = end_pint;

    vector routePOSTION;

    routePOSTION.push_back(point->m_pos);

    while (point->m_last!=nullptr) {

        point = point->m_last;

        routePOSTION.push_back(point->m_pos);

    }

    

    int count = pointList.size();

    for (int i = 0; i

        vector* points = pointList.at(i);

        for (int j = 0; jsize();j++) {

            POINT* point = points->at(j);

            

            Sprite* spr = Sprite::create("ui_b_next.png");

            layer->addChild(spr,2);

            spr->setPosition(Vec2(boardDIS+point->m_pos.x*DIS,boardDIS2-point->m_pos.y*DIS));

            spr->setVisible(false);

            spr->runAction(Sequence::create(DelayTime::create(i*1),CallFunc::create([=](){spr->setVisible(true);}),nullptr));

            spr->setColor(Color3B(60,60,60));

            

            Size size = spr->getContentSize();

            auto label = Label::createWithTTF(__String::createWithFormat("%d",i)->getCString(),"fonts/Marker Felt.ttf", 12);

            label->setPosition(Vec2( size.width/2, size.height/2));

            spr->addChild(label);

            

        }

        

    }

    

//    int count = (int)routePOSTION.size();

//    for (int i = 0; i

//        Sprite* spr = Sprite::create("ui_b_next.png");

//        layer->addChild(spr,2);

//        spr->setPosition(Vec2(boardDIS+routePOSTION.at(count-1-i).x*DIS,boardDIS2-routePOSTION.at(count-1-i).y*DIS));

//        spr->setVisible(false);

//        spr->runAction(Sequence::create(DelayTime::create(i*1),CallFunc::create([=](){spr->setVisible(true);}),nullptr));

//    }

//    

    Sprite* spr = Sprite::create("ui_record.png");

    layer->addChild(spr,1);

    spr->setPosition(Vec2(boardDIS+end.x*DIS,boardDIS2-end.y*DIS));



}

蜗牛lxy
关注
C++实现A*寻路
weixin_43701019的博客
02-02 828
A*寻路原理可查看之前的文章:游戏AI中的寻路算法（A*算法） 上面的是C#，下面是用C++实现的Astart类（大致一样），main函数就要自己构造地图和随机： //Astart.h //路径的节点 struct Node { int x; //坐标 int y; int G; //从起点到当前位置的值 int H; //从当前位置到终点预...
A*寻路算法C++实现
最新发布
McQueen_LT的博客
02-12 157
【代码】A*寻论算法C++实现。
A*寻路算法C++简单实现
热门推荐
踏莎行的博客
07-30 2万+
参考文章： http://www.policyalmanac.org/games/aStarTutorial.htm   这是英文原文《A*入门》，最经典的讲解，有demo演示 http://www.cnblogs.com/technology/archive/2011/05/26/2058842.html  这是国人翻译后整理的简版，有简单代码demo，不过有些错误，讲得很清晰，本文图片来自...
a*寻路算法,c++类
03-07
纯Ｃ++算法类，头文件有注释，调用简单，速度极快
C++实现A*寻路算法
crazybobo1207的博客
11-07 1665
和dijkstra算法一样，整个图是慢慢被探索的，所以也需要定义两个集合，一个是已经处理（探索）过的点的集合，另一个是待处理的点的集合（“待处理的点的集合”并不等于“未处理过的点的集合”，前者指的是已经看到但未处理的点，后者还包括那些在远处尚未看到的点）。A*算法的核心公式是F（起点到终点的距离）=G（起点到当前点的距离，即已经走过的路）+H（当前点到终点的距离，即还没走过的路）。2.将该点的8个邻接点（边界点、障碍物、已经处理过的点，这三者除外）放入open_list中，当遇到了终点时，break;
A*寻路算法C++实现源码详解
A*算法是一种被广泛应用于路径规划和寻路问题的高效算法。它结合了最好优先搜索和Dijkstra算法的优点，在许多领域如人工智能、游戏开发和机器人导航等都有应用。 ## A*算法知识点详述 ### 算法原理 A*算法的核心...
Cocos2dx A*寻路算法C++实现教程
描述部分提到的“一个A星寻路算法C++小样例”，意味着在该文件中包含了实现A*算法的一个简单实例，可能是一个开源的代码样例。这个样例可能包含算法的核心代码，例如节点评估、路径扩展、成本计算等功能。开发者可以...
A*寻路算法的C++简单实现
编程资料大全
04-05 266
2007/8/13 17:26:59 #include &lt;iostream&gt; #include &lt;ctime&gt; #include &lt;list&gt; #include &lt;algorithm&gt; #include &lt;cassert&gt; using namespace std; class AStarPos { public: ...
A*算法、自动寻路算法C++源码
11-21
A*算法的C++实现，注释详尽，直接编译运行
a*寻路 c++实现
11-02
a*寻路算法, 八方向 ,c++ 二叉堆 实现，vs2010下可直接编译运行 可用于游戏寻路等 注：这是某开源代码的修正版，原版有错误和无意义代码，不能发就算了
AStarPathFinder_CPP:C ++中的A *路径查找实现
03-28
AStarPathFinder_CPP C ++中的A *路径查找实现
C++实现的高效A*算法
04-08
A-Star Algorithm 这是使用C++实现的高效的A-Star算法。只对算法的程序实现做了尽力而为的优化，并没有对算法自身进行改良。优化措施主要在于：快速判断路径节点是否在开启/关闭列表中、快速查找最小f值的节点以及优化路径节点频繁分配内存的问题。 运行环境 支持c++11的编译器 使用示例 char maps[10][10] = { { 0, 1, 0, 0, 0, 1, 0, 0, 0, 0 }, { 0, 0, 0, 1, 0, 1, 0, 1, 0, 1 }, { 1, 1, 1, 1, 0, 1, 0, 1, 0, 1 }, { 0, 0, 0, 1, 0, 0, 0, 1, 0, 1 }, { 0, 1, 0, 1, 1, 1, 1, 1, 0, 1 }, { 0, 1, 0, 0, 0, 0, 0, 0, 0, 1 }, { 0, 1, 1, 1, 1, 1, 1, 1, 1, 1 }, { 0, 0, 0, 0, 1, 0, 0, 0, 1, 0 }, { 1, 1, 0, 0, 1, 0, 1, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 1, 0, 1, 0 }, }; // 搜索参数 AStar::Params param; param.width = 10; param.height = 10; param.corner = false; param.start = AStar::Vec2(0, 0); param.end = AStar::Vec2(9, 9); param.can_pass = [&](const AStar::Vec2 &pos)->bool { return maps[pos.y][pos.x] == 0; }; // 执行搜索 BlockAllocator allocator; AStar algorithm(&allocator); auto path = algorithm.find(param); 编译代码 make build && cd build cmake ../example && make
A星算法自动寻路(C++源代码）
06-20
A星算法自动寻路(C++源代码），供大家学习使用
A*寻路算法c++版（第一版）
wqzhang2017的博客
03-12 2104
用了一周时间将A*算法的操作流程理解并编程实现，整个过程从开始理解算法的具体内容到将程序调试好并能够在20*20的方格上实现寻路，时间分配如下：1.周一~周三：理解A*算法含义2.周四~周日：编程、调试注：最开始学习A*算法的时候，刚理解了A*大概的思路就感觉很简单，真正编程去实现时和概念上的A*格格不入。先聊一下A*的概念： 就是在保证从起点开始向外扩展点的代价g(n)最...
A*寻路算法的实现
Gnorth的专栏
06-21 5794
原理：http://www.cppblog.com/christanxw/archive/2006/04/07/5126.html 算法理论请到原理这个传送门，代码中的注释，已经比较详细，所以我不会讲太多的原理，该文章本身就是以A*的思路，对算法进行一次速度上的优化，用一些更效率的方式来代替算法原理中必要的步骤。 针对算法原理，做出如下改动： 抛弃关闭列表，取而代之的是根据地图数据生成一个B
A*寻路C++ 代码
weixin_43374319的博客
12-19 531
    #include "AStar.h" //准备一张 开标 和 闭表 std::vector&lt;CAStar::_NODE&gt;CAStar::open; std::vector&lt;CAStar::_NODE&gt;CAStar::close; #define _ABS(v) ((v) &lt; 0 ? -(v):(v)) #define _H_V(c, e) (_ABS...
AL游戏中的自动寻路——A*算法详解（C++实现）
qq_54169998的博客
02-07 8536
一、A*算法的一个应用实例：迷宫寻路【下面是A*算法的一个应用实例：迷宫寻路。在日趋流行的3D游戏中，如何使非玩家控制角色准确实现自动寻路功能成为3D 开发技术中一大研究热点。其中A*算法得到大量运用。A*算法与传统路径规划算法相比，实时性更高、灵活性更强、寻路结果更贴近人工选择路径结果。A*寻路算法并不是找到最优路径，只是找到相对近的路径，因为赵最优路径要把所有可行路径都找出来进行对比，消耗性能太大，寻路效果只要想读路径就行了。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值