以下是一个示例的C#语言下的A*算法和Dijkstra算法的完整代码：
using System;
using System.Collections.Generic;
public class Node
{
public int x;
public int y;
public bool isWalkable;
public List<Node> neighbors;
public Node parent;
public int gCost; // 从起点到当前节点的实际移动代价
public int hCost; // 从当前节点到目标节点的估算代价
public Node(int x, int y, bool isWalkable)
{
this.x = x;
this.y = y;
this.isWalkable = isWalkable;
neighbors = new List<Node>();
}
public int fCost { get { return gCost + hCost; } }
}
public class Pathfinding
{
// A*算法寻找路径
public static List<Node> AStar(Node startNode, Node endNode)
{
List<Node> openSet = new List<Node>();
HashSet<Node> closedSet = new HashSet<Node>();
openSet.Add(startNode);
while (openSet.Count > 0)
{
Node currentNode = openSet0;
for (int i = 1; i < openSet.Count; i++)
{
if (openSeti.fCost < currentNode.fCost || openSeti.fCost == currentNode.fCost && openSeti.hCost < currentNode.hCost)
{
currentNode = openSeti;
}
}
openSet.Remove(currentNode);
closedSet.Add(currentNode);
if (currentNode == endNode)
{
return GeneratePath(startNode, endNode);
}
foreach (Node neighbor in currentNode.neighbors)
{
if (!neighbor.isWalkable || closedSet.Contains(neighbor))
{
continue;
}
int newCostToNeighbor = currentNode.gCost + GetDistance(currentNode, neighbor);
if (newCostToNeighbor < neighbor.gCost || !openSet.Contains(neighbor))
{
neighbor.gCost = newCostToNeighbor;
neighbor.hCost = GetDistance(neighbor, endNode);
neighbor.parent = currentNode;
if (!openSet.Contains(neighbor))
{
openSet.Add(neighbor);
}
}
}
}
return null;
}
// Dijkstra算法寻找路径
public static List<Node> Dijkstra(Node startNode, Node endNode)
{
Dictionary<Node, int> distance = new Dictionary<Node, int>();
Dictionary<Node, Node> previous = new Dictionary<Node, Node>();
List<Node> unvisited = new List<Node>();
foreach (Node node in GetAllNodes())
{
distancenode = int.MaxValue;
previousnode = null;
unvisited.Add(node);
}
distancestartNode = 0;
while (unvisited.Count > 0)
{
Node current = null;
foreach (Node node in unvisited)
{
if (current == null || distancenode < distancecurrent)
{
current = node;
}
}
if (current == endNode)
{
return GeneratePath(startNode, endNode);
}
unvisited.Remove(current);
foreach (Node neighbor in current.neighbors)
{
int altDistance = distancecurrent + GetDistance(current, neighbor);
if (altDistance < distanceneighbor)
{
distanceneighbor = altDistance;
previousneighbor = current;
}
}
}
return null;
}
// 计算两个节点之间的距离
public static int GetDistance(Node nodeA, Node nodeB)
{
int distanceX = Math.Abs(nodeA.x - nodeB.x);
int distanceY = Math.Abs(nodeA.y - nodeB.y);
return distanceX + distanceY;
}
// 生成路径
public static List<Node> GeneratePath(Node startNode, Node endNode)
{
List<Node> path = new List<Node>();
Node currentNode = endNode;
while (currentNode != startNode)
{
path.Add(currentNode);
currentNode = currentNode.parent;
}
path.Reverse();
return path;
}
// 获取所有节点
public static List<Node> GetAllNodes()
{
List<Node> allNodes = new List<Node>();
// 在这里根据实际场景生成所有节点并设置邻居节点
return allNodes;
}
}
class Program
{
static void Main(string\[\] args)
{
Node startNode = new Node(0, 0, true); // 起始节点
Node endNode = new Node(9, 9, true); // 目标节点
// 使用A*算法寻找路径
List<Node> aStarPath = Pathfinding.AStar(startNode, endNode);
if (aStarPath != null)
{
Console.WriteLine("A* Algorithm - Path Found:");
foreach (Node node in aStarPath)
{
Console.WriteLine("(" + node.x + ", " + node.y + ")");
}
}
else
{
Console.WriteLine("A* Algorithm - No Path Found.");
}
// 使用Dijkstra算法寻找路径
List<Node> dijkstraPath = Pathfinding.Dijkstra(startNode, endNode);
if (dijkstraPath != null)
{
Console.WriteLine("Dijkstra Algorithm - Path Found:");
foreach (Node node in dijkstraPath)
{
Console.WriteLine("(" + node.x + ", " + node.y + ")");
}
}
else
{
Console.WriteLine("Dijkstra Algorithm - No Path Found.");
}
}
}
在示例代码中，我们定义了一个 Node 类来表示节点对象，该类包含节点的坐标、是否可行走、邻居节点等信息。然后，我们在 Pathfinding 类中实现了 A*算法和 Dijkstra 算法来寻找路径。GetDistance 函数用于计算两个节点之间的距离，GeneratePath 函数用于生成路径，GetAllNodes 函数用于获取所有节点。
在 Main 函数中，我们创建了起始节点和目标节点，并使用 A*算法和 Dijkstra 算法分别寻找路径。最后，将路径打印出来。
请注意，示例代码中只包含了算法的实现逻辑，您需要根据实际情况创建地图、设置节点可行走状态、设置邻居节点等操作。