A*中的二叉堆

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

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

 

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