A*算法(二)

最新推荐文章于 2025-07-23 22:59:22 发布
最新推荐文章于 2025-07-23 22:59:22 发布
阅读量949 收藏 1
点赞数
分类专栏： AI 文章标签： 算法 list null class c

代码中使用的链表List为作者自己写的，不是标准库的。原文章未把自写List粘贴出来，所以想要看List这部分代码的，可以去作者提供的地址下载，一个叫A星算法自寻路的文件，里面有控制台、win32和精灵三个版本的A*算法演示程序，还有List的源文件，地址:lj56456311.ys168.com/

作者把A星算法封装成了一个类(Astart)，大家可以通过代码来学习。

///////////////////////////////////////////////////////////////
//Astart.h
///////////////////////////////////////////////////////////////
#pragma once
#include "List.h"
class Rect    //结点,也就是每个格子
{
public:
   int map_x;   //在地图中的列数
   int map_y;   //在地图中的行数
   int h_value; // H值
    int g_value; // G值
    Rect *pre;   // 父结点指针
};

class Astart
{
public:
//构造函数中 a 为一个二维数组,代表地图,这个类有个缺点就是使用不
//同大小的地图时你得手动修改这里的a[10][10]和下面的map[10][10]的大小
//w为地图的列数,l为地图的行数,s为起点结点编号,e为终点结点编号;
   Astart(int a[10][10],int w,int l,int s,int e);           
    ~Astart(void);
    bool Find();   //寻找最短路径
    int get_h_value(int i);   //获取H值
    int get_g_value(int i);   //获取G值
    void GetResult(); //获取结果,让最短路径的结点值修改为2
    int map[10][10];   //地图对象,用来保存构造函数中传递进来的地图信息,这里的大小也要实际运用来改变
private:
   Rect *rect; //结点指针,最后通过该指针来遍历最短路径
    int WIDTH;    //地图的列数
    int LENGTH;   //地图的行数
    int start;    //起点结点编号
    int end;      //终点结点编号
    List<int> open_list;   //OPEN表
    List<int> close_list; //CLOSE表
};


///////////////////////////////////////////////////////////////
//Astart.cpp
///////////////////////////////////////////////////////////////

#include <math.h>#include ".\astart.h"
#include "List.cpp"
#include <math.h>
Astart::Astart(int a[10][10],int w,int l,int s,int e)
{
    for(int i=0; i<l; i++)
    {
       for(int j=0; j<w; j++)
      {
          map[i][j] = a[i][j];
       }
    }
    WIDTH = w;
    start = s;
    end = e;
    LENGTH = l;
    rect = new Rect[WIDTH*LENGTH];
    for(int i=0; i<WIDTH*LENGTH; i++)
    {
       rect[i].map_x = i%WIDTH;
       rect[i].map_y = i/WIDTH;
    }
    rect[start].g_value = 0;
    rect[start].pre = NULL;
}

Astart::~Astart(void)
{
}

bool Astart::Find()
{
    if(close_list.IsEmpty())
    {
       if((start+WIDTH)/WIDTH < LENGTH && (start+WIDTH)/WIDTH >=0 && (start+WIDTH)%WIDTH >=0&& (start+WIDTH)%WIDTH < WIDTH)
      {
          if( map[(start+WIDTH)/WIDTH][(start+WIDTH)%WIDTH]!=1 )
          {
             rect[start+WIDTH].pre = &rect[start];
             rect[start+WIDTH].h_value = get_h_value(start+WIDTH);
             rect[start+WIDTH].g_value = get_g_value(start+WIDTH);
             open_list.Insert(open_list.Length(),start+WIDTH);
          }
       }
       if((start-WIDTH)/WIDTH < LENGTH && (start-WIDTH)/WIDTH >=0 && (start-WIDTH)%WIDTH >= 0 &&(start-WIDTH)%WIDTH < WIDTH)
       {
          if( map[(start-WIDTH)/WIDTH][(start-WIDTH)%WIDTH]!=1)
          {
             rect[start-WIDTH].pre = &rect[start];
             rect[start-WIDTH].h_value = get_h_value(start-WIDTH);
             rect[start-WIDTH].g_value = get_g_value(start-WIDTH);
             open_list.Insert(open_list.Length(),start-WIDTH);
          }
       }
       if((start+1)/WIDTH < LENGTH && (start+1)/WIDTH >=0 && (start+1)%WIDTH >= 0 && (start+1)%WIDTH < WIDTH)
   {
    if( map[(start+1)/WIDTH][(start+1)%WIDTH]!=1)
    {
     rect[start+1].pre = &rect[start];
     rect[start+1].h_value = get_h_value(start+1);
     rect[start+1].g_value = get_g_value(start+1);
     open_list.Insert(open_list.Length(),start+1);
    }
   }
   if((start-1)/WIDTH < LENGTH && (start-1)/WIDTH >=0 && (start-1)%WIDTH >= 0 && (start-1)%WIDTH < WIDTH)
   {
    if( map[(start-1)/WIDTH][(start-1)%WIDTH]!=1)
    {
     rect[start-1].pre = &rect[start];
     rect[start-1].h_value = get_h_value(start-1);
     rect[start-1].g_value = get_g_value(start-1);
     open_list.Insert(open_list.Length(),start-1);
    }
   }
   close_list.Insert(close_list.Length(),start);
}
int i = 0;
int num = -1;
int rectcount = 0;
for(int z=1; z<=open_list.Length(); z++)
{
   int counttemp,numtemp;
   open_list.Find(z,counttemp);
   numtemp = rect[counttemp].h_value + rect[counttemp].g_value;
   if(num==-1)
   {
    num = numtemp;
   }
   if(numtemp <= num)
   {
    i = z;
    num = numtemp;
    rectcount = counttemp;
   }
}
int temp;
if(i==0)
{
   return false;
}
open_list.Delete(i,temp);
close_list.Insert(close_list.Length(),rectcount);
if((rectcount+WIDTH)/WIDTH < LENGTH && (rectcount+WIDTH)/WIDTH >=0 && (rectcount+WIDTH)%WIDTH >= 0 && (rectcount+WIDTH)%WIDTH < WIDTH)
{
   if(rectcount+WIDTH == end)
   {
    rect[rectcount+WIDTH].pre = &rect[rectcount];
    return true;
   }
   if( map[(rectcount+WIDTH)/WIDTH][(rectcount+WIDTH)%WIDTH]!=1 )
   {
    if(close_list.Search(rectcount+WIDTH) == 0)
    {
     if(open_list.Search(rectcount+WIDTH) == 0)
     {
      rect[rectcount+WIDTH].pre = &rect[rectcount];
      rect[rectcount+WIDTH].h_value = get_h_value(rectcount+WIDTH);
      rect[rectcount+WIDTH].g_value = get_g_value(rectcount+WIDTH);
      open_list.Insert(open_list.Length(),rectcount+WIDTH);
     }
     else
     {
      if(rect[rectcount].g_value + 10 < rect[rectcount+WIDTH].g_value)
      {
       rect[rectcount+WIDTH].pre = &rect[rectcount];
       rect[rectcount+WIDTH].g_value = get_g_value(rectcount+WIDTH);
      }
     }
    }
   }
}
if((rectcount-WIDTH)/WIDTH < LENGTH && (rectcount-WIDTH)/WIDTH >=0 && (rectcount-WIDTH)%WIDTH >= 0 && (rectcount-WIDTH)%WIDTH < WIDTH)
{
   if(rectcount-WIDTH == end)
   {
    rect[rectcount-WIDTH].pre = &rect[rectcount];
    return true;
   }
   if( map[(rectcount-WIDTH)/WIDTH][(rectcount-WIDTH)%WIDTH]!=1)
   {
    if(close_list.Search(rectcount-WIDTH) == 0)
    {
     if(open_list.Search(rectcount-WIDTH) == 0)
     {
      rect[rectcount-WIDTH].pre = &rect[rectcount];
      rect[rectcount-WIDTH].h_value = get_h_value(rectcount-WIDTH);
      rect[rectcount-WIDTH].g_value = get_g_value(rectcount-WIDTH);
      open_list.Insert(open_list.Length(),rectcount-WIDTH);
     }
     else
     {
      if(rect[rectcount].g_value + 10 < rect[rectcount-WIDTH].g_value)
      {
       rect[rectcount-WIDTH].pre = &rect[rectcount];
       rect[rectcount-WIDTH].g_value = get_g_value(rectcount-WIDTH);
      }
     }
    }
   }
}
if((rectcount+1)/WIDTH < LENGTH && (rectcount+1)/WIDTH >=0 && (rectcount+1)%WIDTH >= 0 && (rectcount+1)%WIDTH < WIDTH && rectcount%(WIDTH-1)!=0)
{
   if(rectcount+1 == end)
   {
    rect[rectcount+1].pre = &rect[rectcount];
    return true;
   }
   if( map[(rectcount+1)/WIDTH][(rectcount+1)%WIDTH]!=1)
   {
    if(close_list.Search(rectcount+1) == 0)
    {
     if(open_list.Search(rectcount+1) == 0)
     {
      rect[rectcount+1].pre = &rect[rectcount];
      rect[rectcount+1].h_value = get_h_value(rectcount+1);
      rect[rectcount+1].g_value = get_g_value(rectcount+1);
      open_list.Insert(open_list.Length(),rectcount+1);
     }
     else
     {
      if(rect[rectcount].g_value + 10 < rect[rectcount+1].g_value)
      {
       rect[rectcount+1].pre = &rect[rectcount];
       rect[rectcount+1].g_value = get_g_value(rectcount+1);
      }
     }
    }
   }
}
if((rectcount-1)/WIDTH < LENGTH && (rectcount-1)/WIDTH >=0 && (rectcount-1)%WIDTH >= 0 && (rectcount-1)%WIDTH < WIDTH && rectcount%WIDTH!=0)
{
   if(rectcount-1 == end)
   {
    rect[rectcount-1].pre = &rect[rectcount];
    return true;
   }
   if( map[(rectcount-1)/WIDTH][(rectcount-1)%WIDTH]!=1)
   {
    if(close_list.Search(rectcount-1) == 0)
    {
     if(open_list.Search(rectcount-1) == 0)
     {
      rect[rectcount-1].pre = &rect[rectcount];
      rect[rectcount-1].h_value = get_h_value(rectcount-1);
      rect[rectcount-1].g_value = get_g_value(rectcount-1);
      open_list.Insert(open_list.Length(),rectcount-1);
     }
     else
     {
      if(rect[rectcount].g_value + 10 < rect[rectcount-1].g_value)
      {
       rect[rectcount-1].pre = &rect[rectcount];
       rect[rectcount-1].g_value = get_g_value(rectcount-1);
      }
     }
    }
   }
}
return Find();
}

int Astart::get_h_value(int i)
{
return ((abs(end/WIDTH - i/WIDTH) + abs(end%WIDTH - i%WIDTH)) * 10);
}

int Astart::get_g_value(int i)
{
return (rect[i].pre->g_value + 10);
}

void Astart::GetResult()
{
Rect *p = &rect[end];
while(p != NULL)
{
   map[p->map_y][p->map_x] = 2;
   p = p->pre;
}
}


///////////////////////////////////////////////////////////////
//main.cpp
///////////////////////////////////////////////////////////////
#include <iostream>
#include "Astart.h"
#include "List.h"
#include "List.cpp"
using namespace std;
const int WIDTH = 10; //地图列数
const int LENGTH = 10; //地图行数
Rect rect[WIDTH*LENGTH];//定义rect数组,存放所有格子rect[0]代表0号格子一直到rect[WIDTH*LENGTH];

List<int> open_list;
List<int> close_list;
int start = 0; //起点编号为0（左上角）
int end = 99;   //终点编号为99（右下角）
//地图信息
int map[10][10]={
     {0,0,1,0,0,0,0,1,0,0},
     {0,0,1,1,0,0,0,1,0,0},
     {1,0,0,0,1,0,0,1,0,0},
     {1,0,1,1,1,1,1,1,0,0},
     {1,0,0,0,0,0,0,1,0,0},
     {1,0,0,0,0,0,0,1,0,0},
     {1,0,0,0,0,0,0,1,0,0},
     {1,0,0,0,0,0,0,1,0,0},
     {1,0,0,0,0,0,0,0,0,0},
     {1,0,0,0,0,0,0,1,0,0}
     };

//主函数
void main()
{
Astart a(map,WIDTH,LENGTH,start,end);
if(!a.Find())
{
   cout<<"无可到达的路线!"<<endl;
   return;
}
a.GetResult();
for(int i=0;i<LENGTH;i++)
{
   for(int j=0;j<WIDTH;j++)
   {
    cout<<a.map[i][j]<<" ";
   }
   cout<<endl;
}
}

转载自: http://hi.baidu.com/%BA%DA%B5%C4%B7%A2%D7%CF/blog/item/ded949953be42e4ed0135ef3.html

C++实现A*寻路
weixin_43701019的博客
02-02 822
A*寻路原理可查看之前的文章:游戏AI中的寻路算法（A*算法） 上面的是C#，下面是用C++实现的Astart类（大致一样），main函数就要自己构造地图和随机： //Astart.h //路径的节点 struct Node { int x; //坐标 int y; int G; //从起点到当前位置的值 int H; //从当前位置到终点预...
混合A*算法
sunyao1314的博客
04-19 1644
它通过维护两个列表（开放列表和封闭列表），根据启发式函数（估计函数）和已走过路径的成本来选择下一个状态，直到找到目标状态。：采样优化技术是一种在连续空间中搜索路径的方法，它通过对状态空间进行采样，并在采样点之间进行插值，以搜索更加精确的路径。算法在离散状态空间中进行搜索，同时利用采样优化技术在连续状态空间中进行路径优化。：利用A*算法在离散状态空间中搜索路径，根据启发式函数和已走过路径的成本选择下一个状态，直到找到目标状态。在混合A*中，可以通过在当前状态周围采样，并计算采样点的成本来生成后继状态。
Astart（C++）.zip
07-01
A星c++版--进行了解耦，基本上可以通用 算法讲解：https://blog.youkuaiyun.com/qq_45620703/article/details/118368359
A*算法（超级详细讲解，附有举例的详细手写步骤）
热门推荐
dujuancao11的博客
11-17 14万+
背景：项目需要接触此算法，以下是一些自学成果，如有不足之处，欢迎指出，必虚心接受。做了一份PPT来汇报，此处直接使用自己PPT的截图。部分图片来源网络，如有侵权立马删除，以下博文仅作为学习笔记。 目录 A*寻路算法 A*算法解决什么问题 A*算法的基本原理 A*算法的详细原理 A*算法的详细原理之定义 ​A*算法的详细原理之初始设定 ​A*算法的详细原理之寻路原理 A*算法的详细原理之结束条件 A*算法的寻路详细步骤 A*算法的举例说明 A*算法的伪代码 A*算法的定义伪....
用c++写A*算法
qq_59143106的博客
03-05 1469
【代码】用c++写A*算法。
A*算法流程、注意事项、代码实现
m0_69611489的博客
09-22 2602
本篇文章主要介绍了A星算法简介、算法流程、代码实现注意事项和代码实现，内容比较精简、完整，适合学习算法时参考。
【MATLAB源码-第208期】基于matlab的改进A*算法和传统A*算法对比仿真；改进点：1.无斜穿障碍物顶点2.删除中间多余节点，减少转折。
2401_83582367的博客
09-04 2896
在路径的安全性方面，改进A*算法通过避免斜穿障碍物顶点，有效减少了潜在的碰撞风险，保证了路径的安全可靠。在路径的平滑性方面，改进A*算法通过删除中间多余节点和减少转折，使路径更加直观和平滑，提高了路径的效率和可靠性。这样一来，生成的路径将不会斜穿任何障碍物顶点，从而避免了潜在的碰撞风险。传统A*算法生成的路径往往包含许多不必要的中间节点，这些节点会增加路径的转折点，使路径变得曲折，从而增加行驶时间和能耗。删除中间多余节点，减少转折：通过路径优化，删除不必要的中间节点，使路径更加平滑，减少了行驶时间和能耗。
A*算法（二）：8方向
PYJTLK的博客
01-26 2954
上一篇文章讲解了A*算法的最简版本，本篇文章在4方向A*算法的基础上讲解8方向的情况。 准备工作 在讲解8方向A*算法前，我们需要想想这个“最小代价”是指什么。 第一种情况，如下图，如果离开A到周围的8个方格的代价均是1，那么从起点到终点的“最小代价”就是指最少需要走几步。 第二种情况，如下图，如果斜着走的代价是√2，那么从起点到终点的“最小代价”就是指最小距离长度。 和上一篇一样，我们给方格定义变量A、B、C ...
A*算法（C++实现）
A_L_A_N
08-03 3万+
简易地图 如图所示简易地图, 其中绿色方块的是起点 (用 A 表示), 中间蓝色的是障碍物, 红色的方块 (用 B 表示) 是目的地. 为了可以用一个二维数组来表示地图, 我们将地图划分成一个个的小方块. 二维数组在游戏中的应用是很多的, 比如贪吃蛇和俄罗斯方块基本原理就是移动方块而已. 而大型游戏的地图, 则是将各种"地貌"铺在这样的小方块上. 寻路步骤 1. 从起点A开始, 把它作...
二维A*算法路径规划matlab代码
11-16
以复杂岛屿地图为例，做了二维A*路径规划。代码为MATLAB代码，解压后可以直接运行。文件夹内Astar优快云为主文件，TrunToGridMap为地图转栅格文件，child_nodes_cal为计算子节点的函数，1234d.jpg为地图图片。
移动机器人路径规划 几种A*算法改进matlab实现
12-05
在MATLAB中实现A*算法，首先需要建立环境地图模型，通常使用二维数组表示，0表示可通行区域，1表示障碍物。然后定义启发式函数，如欧几里得距离或曼哈顿距离。接着，设置起始节点和目标节点，初始化开放列表和关闭...
A*算法实验
Zebras_zhku的博客
04-15 4693
一、实验目的： 熟悉和掌握启发式搜索的定义、估价函数和算法过程，并利用A*算法求解N数码难题，理解求解流程和搜索顺序。 二、实验原理： A*算法是一种有序搜索算法，其特点在于对估价函数的定义上。对于一般的有序搜索，总是选择f值最小的节点作为扩展节点。因此，f是根据需要找到一条最小代价路径的观点来估算节点的，所以，可考虑每个节点n的估价函数值为两个分量：从起始节点到节点n的代价以及从节点n到达目标节...
用java实现A*寻路算法
StreamlineWq的博客
03-07 3515
最近的开发中遇到了寻路这个知识点，然后去了解了一下最常见的A算法，本会会结合我的理解，用最通俗易懂的话语讲解A算法的原理，下面会给出代码示例。说到寻路算法，就涉及到了图的遍历，然后又分为深度优先和广度优先等等，这些知识点大家随便一搜就能查到，为了方便这里给个，里面有介绍算法的发展史。在A出来之前，遍历算法要不就是效率不高，要不就是不是最优路径，A的出现，是结合了前面的有点，所以说A*只是相对来说效率很高的一种算法。
详解混合A*算法Hybrid A*
zgw555555的专栏
05-26 2764
混合A算法（Hybrid A）是一种改进的路径规划算法，特别针对车辆动力学进行了优化。
【PTA数据结构 | C语言版】堆中的路径
等风来
07-20 763
将一系列给定数字插入一个初始为空的最小堆 h。随后对任意给定的下标 i，打印从第 i 个结点到根结点的路径。输入格式:每组测试第 1 行包含 2 个正整数 n 和 m (≤10^3)，分别是插入元素的个数、以及需要打印的路径条数。下一行给出区间 [−10^4,10^4] 内的 n 个要被插入一个初始为空的小顶堆的整数。最后一行给出 m 个下标。输出格式:对输入中给出的每个下标 i，在一行中输出从第 i 个结点到根结点的路径上的数据。数字间以 1 个空格分隔，行末不得有多余空格。
代码随想录算法训练营第二十九天
最新发布
2403_87481241的博客
07-23 955
问题描述：假设有打乱顺序的一群人站成一个队列，数组 people 表示队列中的一些人的属性（每个 people [i] = [h, k] 表示第 i 个人的身高为 h，前面正好有 k 个身高大于或等于 h 的人）。如果存在，返回该起点的索引；这个算法的时间复杂度是 O (n)，空间复杂度是 O (1)，非常高效。这个算法的时间复杂度是 O (n²)（排序 O (nlogn) + 插入操作 O (n²)），空间复杂度是 O (n)。这个算法的时间复杂度是 O (n)，空间复杂度是 O (n)。
飞算JavaAI：基于算法的测评，飞算AI 初学者入门级实测体验
2302_81805546的博客
07-21 660
“别怕算法，它比你想象的要友好得多。只要你愿意动手写代码，飞算AI会陪你一起进步。”
枚举右，维护左基础篇
m0_68367618的博客
07-23 274
本文总结了力扣题单中基于双变量问题的通用解法模板。核心思路是：通过维护已遍历区间（使用哈希表、集合或滑动窗口），枚举未遍历区间来优化双变量问题。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值