AStar 寻路方法:使用二叉堆来获取当前权值最小的节点,使用链表的方式保存节点路径(也可认为是树结构)
using UnityEngine;
using System.Collections;
namespace AStar
{
public class NodeBinaryHeap
{
public const int MAX_SIZE = 512;
public int HeapSize{get; private set;}
private TreeNode[] _HeapArray;
public NodeBinaryHeap()
{
Clear();
_HeapArray = new TreeNode[MAX_SIZE];
}
public void Clear()
{
HeapSize = 0;
}
public bool IsEmpty{get{return HeapSize == 0;}}
private bool MinComp(float x, float y)
{
return x < y;
}
private bool MaxComp(float x, float y)
{
return x > y;
}
// 添加新元素,采用冒泡法
public void Push(TreeNode x)
{
//首先将 元素放到列表最后面
HeapSize++;
_HeapArray[HeapSize] = x;
// 递归的和其父节点比较,如果,小于父节点就和父节点交换,直至大于等于父节点的值
int i = 0;
for(i = HeapSize; i > 0; i = i/ 2)
{
int parentIndex = i/2;
if(parentIndex <= 0)
{
break;
}
if(MinComp(x.F, _HeapArray[parentIndex].F))
{
_HeapArray[i] = _HeapArray[parentIndex];
}
else
{
break;
}
}
_HeapArray[i] = x;
}
// 删除元素,采用向下沉的方式
public TreeNode Pop()
{
if(IsEmpty)
{
return null;
}
// 取出第一个元素
TreeNode popNode = _HeapArray[1];
if(HeapSize == 1)
{
HeapSize--;
return popNode;
}
// 取出最后一个元素
TreeNode lastNode = _HeapArray[HeapSize];
HeapSize--;
// 采用向下沉的方式向下沉
int i = 1;
for(; i <= HeapSize;)
{
// 如果两个子节点存在,就挑选其中较小的值作为父节点的值
if((2 * i + 1) <= HeapSize)
{
int index = MinComp(_HeapArray[ 2* i].F, _HeapArray[2 * i + 1].F)? (2 * i): (2 * i + 1);
if(MinComp(_HeapArray[index].F, lastNode.F))
{
_HeapArray[i] = _HeapArray[index];
i = index;
}
else
{
break;