A*寻路算法打开列表二叉堆代码整理

using System;

namespace BinaryHeaps
{
    public class BinaryHeaps
    {
        int[] fCost = new int[1];// 二叉堆 开启列表F值花费 数组索引标志该F值对应数据的索引标志
        int numberOfOpenListItems; // 总共长度 同时对应fCost最后的索引

        /// <summary>
        /// 自动扩大数组长度
        /// </summary>
        void checkArrayLeght()
        {
            if (fCost.Length > numberOfOpenListItems * 2)
                return;
            int[] temp = new int[fCost.Length * 2];
            for (int i = 1; i < fCost.Length; i++)
            {
                temp[i] = fCost[i];
            }
            fCost = temp;
        }

        /// <summary>
        /// 插入数据
        /// </summary>
        /// <param name="id"></param>
        public void insert(int id)
        {
            ++numberOfOpenListItems;
            checkArrayLeght();
            fCost[numberOfOpenListItems] = id;
            // 上浮
            rise(numberOfOpenListItems);
        }

        /// <summary>
        /// 删除堆顶
        /// </summary>
        public void deleteFist()
        {
            if (numberOfOpenListItems == 0)
                return;
            fCost[1] = fCost[numberOfOpenListItems];
            fCost[numberOfOpenListItems] = 0;
            --numberOfOpenListItems;
            //下沉
            sink(1);
        }

        /// <summary>
        /// 上浮
        /// </summary>
        /// <param name="index"></param>
        void rise(int index)
        {
            if (index == 1)
            {
                return;
            }
            int parentIndex = index / 2;
            //如果父节点比该节点大交换节点
            if (fCost[parentIndex] > fCost[index])
            {
                int temp = fCost[parentIndex];
                fCost[parentIndex] = fCost[index];
                fCost[index] = temp;
                rise(parentIndex);
            }
        }

        /// <summary>
        /// 下沉
        /// </summary>
        /// <param name="index"></param>
        void sink(int index)
        {
            int leftChild = index * 2;
            int rightChild = index * 2 + 1;
            // 与左子节点和右子节点小的那个节点交换
            if (fCost[leftChild] <= fCost[rightChild] && fCost[leftChild] != 0 && fCost[leftChild] < fCost[index])
            {
                int temp = fCost[leftChild];
                fCost[leftChild] = fCost[index];
                fCost[index] = temp;
                sink(leftChild);
            }
            else if (fCost[rightChild] != 0 && fCost[rightChild] < fCost[index])
            {
                int temp = fCost[rightChild];
                fCost[rightChild] = fCost[index];
                fCost[index] = temp;
                sink(rightChild);
            }

        }
        public void Print()
        {
            for (int i = 1; i < numberOfOpenListItems + 1; i++)
            {
                Console.Write(fCost[i] + " ");
            }
            Console.WriteLine();
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            BinaryHeaps binaryHeaps = new BinaryHeaps();
            binaryHeaps.insert(17);
            binaryHeaps.Print();
            binaryHeaps.insert(20);
            binaryHeaps.Print();
            binaryHeaps.insert(30);
            binaryHeaps.Print();
            binaryHeaps.insert(15);
            binaryHeaps.Print();
            binaryHeaps.insert(5);
            binaryHeaps.Print();
            binaryHeaps.insert(40);
            binaryHeaps.Print();
            binaryHeaps.insert(18);
            binaryHeaps.Print();
            binaryHeaps.insert(5);
            binaryHeaps.Print();
            binaryHeaps.deleteFist();
            binaryHeaps.Print();
        }
    }
}

https://blog.csdn.net/u013681996/article/details/39080881
根据这篇文章总结的A*寻路算法打开列表二叉堆代码整理