A*中的二叉堆

        这里贴下二叉堆代码,包装了下vector,存储位置从0开始.可以参照<在A*寻路中使用二叉堆>

  1. //CBinaryHeap.h
  2. #pragma once
  3. #include <vector>
  4. struct Point 
  5. {
  6.     int r,c;
  7. };  //地图行列
  8. struct Node 
  9. {
  10.     int f,g,h;
  11.     int r,c;
  12.     int parent;
  13. };//路径地图节点
  14. class CBinaryHeap
  15. {
  16. public:
  17.     CBinaryHeap(void);
  18. public:
  19.     ~CBinaryHeap(void);
  20. private:
  21.     int m_size; //元素数
  22.     std::vector<Node> elementList;
  23. public:
  24.     void Push(Node &node);  //插入新节点
  25.     void Pop();     //删除顶端
  26.     void Top(Node &out_node);       //返回顶端元素
  27.     int Find(Node &out_node);   //查找相同元素 返回0为没有 如果找到由参数传递
  28.     void Change(int pos,Node &node);    //交换元素 位置从1开始
  29.     bool Empty();   //判断空
  30.     void Clear();   //清空
  31.     int Size(); //大小
  32. };

 

  1. //CBinaryHeap.cpp
  2. #include "BinaryHeap.h"
  3. using namespace std;
  4. CBinaryHeap::CBinaryHeap(void)
  5. {
  6. }
  7. CBinaryHeap::~CBinaryHeap(void)
  8. {
  9. }
  10. void CBinaryHeap::Push(Node &node)  //插入新节点
  11. {
  12.     elementList.push_back(node);
  13.     int index=elementList.size()-1;
  14.     Node temp;
  15.     while (index>0&&elementList[index].f<=elementList[index/2].f)
  16.     {
  17.         temp=elementList[index];
  18.         elementList[index]=elementList[index/2];
  19.         elementList[index/2]=temp;
  20.         index/=2;
  21.     }
  22. }
  23. void CBinaryHeap::Pop()     //删除顶端
  24. {
  25.     elementList[0]=elementList.back();
  26.     elementList.pop_back();
  27.     m_size=elementList.size();
  28.     int v=0,u=1;
  29.     while (true)    //v!=u
  30.     {
  31.         u=v;
  32.         if ((u*2+2)<m_size)
  33.         {
  34.             if (elementList[u].f>=elementList[2*u+1].f)
  35.             {
  36.                 v=2*u+1;    //和左边比较
  37.             }
  38.             if (elementList[v].f>=elementList[2*u+2].f)
  39.             {
  40.                 v=2*u+2;    //用左边和右边比较
  41.             }
  42.         }
  43.         else if (2*u+1<m_size)
  44.         {
  45.             if (elementList[u].f>=elementList[2*u+1].f)
  46.             {
  47.                 v=2*u+1;
  48.             }
  49.         }
  50.         Node temp;
  51.         if (v!=u)
  52.         {
  53.             temp=elementList[u];
  54.             elementList[u]=elementList[v];
  55.             elementList[v]=temp;
  56.         }
  57.         else break;
  58.     }
  59. }
  60. void CBinaryHeap::Top(Node &node)       //返回顶端元素
  61. {
  62.     node=elementList.front();
  63. }
  64. int CBinaryHeap::Find(Node &node)   //查找相同元素
  65. {
  66.     for (int i=0;i<elementList.size();i++)
  67.     {
  68.         if (elementList[i].r==node.r&&elementList[i].c==node.c)
  69.         {
  70.             node=elementList[i];
  71.             return i+1;
  72.         }
  73.     }
  74.     return 0;
  75. }
  76. void CBinaryHeap::Change(int pos,Node &node)    //交换元素
  77. {
  78.     if (pos>0)
  79.     {
  80.         int index=pos-1;
  81.         Node temp;
  82.         elementList[index]=node;
  83.         while (index>0&&elementList[index].f<=elementList[index/2].f)
  84.         {
  85.             temp=elementList[index];
  86.             elementList[index]=elementList[index/2];
  87.             elementList[index/2]=temp;
  88.             index/=2;
  89.         }
  90.     }
  91. }
  92. bool CBinaryHeap::Empty()   //判断空
  93. {
  94.     return elementList.empty();
  95. }
  96. void CBinaryHeap::Clear()   //清空
  97. {
  98.     elementList.clear();
  99. }
  100. int CBinaryHeap::Size() //大小
  101. {
  102.     m_size=elementList.size();
  103.     return m_size;
  104. }
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值