A* 实现 迷宫寻路

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;