Java的A*算法

我整个周末都在玩这个。我正在尝试将节点存储在PriorityQueue数据结构中。我的astar函数似乎没有做它应该做的事情。有人介意看一看吗

public void aStar(Node from, Node to) {

    PriorityQueue<Node> exploreList = new PriorityQueue<Node>();
    ArrayList<Node> visited = new ArrayList<Node>();
    ArrayList<Node> successors = new ArrayList<Node>();

    Node current = from;
    System.out.println(current.getName());
    while (current != to) {
            successors = current.getConnected();
            Collections.sort(successors);
            for (Node n : successors) {
                    if (!visited.contains(n)) {
                            exploreList.add(n);
                    }
                    for (Node n1 : successors) {
                            if (n.fSum() > n1.fSum()) {
                            exploreList.remove(n);
                            exploreList.add(n1);
                            }      
                    }
            }
            visited.add(current);
            current = exploreList.remove();
            System.out.println(current.getName());
    }

public void aStar（节点从，节点到）{
PriorityQueue exploreList=new PriorityQueue（）；
ArrayList visited=新建ArrayList（）；
ArrayList继承者=新的ArrayList（）；
节点电流=从；
System.out.println（current.getName（））；
while（当前！=to）{
继任者=current.getConnected（）；
集合。排序（后继）；
用于（节点n：后续节点）{
如果（！visted.contains（n））{
exploreList.add（n）；
}
对于（节点n1：后续节点）{
如果（n.fSum（）>n1.fSum（））{
exploreList.remove（n）；
exploreList.add（n1）；
}      
}
}
已访问。添加（当前）；
当前=exploreList.remove（）；
System.out.println（current.getName（））；
}

节点类在这里

   public class Node implements Comparable {
   private String name;
   private int travDist;
   private int straightDist;
   private ArrayList<Arc> arcs;

/**
 * Constructor for a new node
 * 
 * @param n
 */
   public Node(String n, int aTravDist, int aStraightDist) {
       name = n;
       travDist = aTravDist;
       straightDist = aStraightDist;

       arcs = new ArrayList<Arc>();
  }

/**
 * Adds a new arc
 * 
 * @param to
 * @param c
 */
public void addArc(Node to, int c) {
    arcs.add(new Arc(to, c));
}

/**
 * Gets the list of connected nodes to this node
 * 
 * @return
 */
public ArrayList<Node> getConnected() {
    ArrayList<Node> returnData = new ArrayList<Node>();
    for (Arc a : arcs) {
        returnData.add(a.getNode());
    }
    return returnData;
}

@Override
public int compareTo(Object o) {
    //return name.compareTo(((Node) o).getName());
    Integer sum = ((Node)o).fSum();
    return sum.compareTo(fSum());
}

public int fSum () {

    return travDist + straightDist;
}

/**
 * Gets the name of the Node
 * 
 * @return
 */
public String getName() {
    return name;
}


}

public类节点实现可比较{
私有字符串名称；
私人旅行社；
私人int直线距离；
私有数组列表弧；
/**
*新节点的构造函数
* 
*@param n
*/
公共节点（字符串n、int aTravDist、int aStraightDist）{
name=n；
travDist=aTravDist；
直线距离=直线距离；
arcs=新的ArrayList（）；
}
/**
*添加新圆弧
* 
*@param to
*@param c
*/
公共void addArc（节点到，int c）{
弧。添加（新弧（到，c））；
}
/**
*获取连接到此节点的节点的列表
* 
*@返回
*/
公共阵列列表getConnected（）{
ArrayList returnData=新的ArrayList（）；
用于（圆弧a：圆弧）{
returnData.add（a.getNode（））；
}
返回数据；
}
@凌驾
公共整数比较对象（对象o）{
//返回name.compareTo（（（节点）o.getName（））；
整数和=（（节点）o）.fSum（）；
返回sum.compareTo（fSum（））；
}
公共int fSum（）{
返回travDist+直线距离；
}
/**
*获取节点的名称
* 
*@返回
*/
公共字符串getName（）{
返回名称；
}
}

您所做的不是正确的a星算法

Collections.sort(successors);

for (Node n1 : successors) {
  if (n.fSum() > n1.fSum()) {
    exploreList.remove(n);
    exploreList.add(n1);
  }      
}

你不应该这么做。在一个明星中，你总是考虑所有的继任者。你不必担心这个顺序——优先级队列会处理这个问题。但是，增加这一行你就增加了算法的复杂度。

Collections.sort(successors);

for (Node n1 : successors) {
  if (n.fSum() > n1.fSum()) {
    exploreList.remove(n);
    exploreList.add(n1);
  }      
}

---

这是完全错误的。你在这里做的是：你只添加所有后继者中最接近的一个。这将是一个大小为1的光束，而不是一个星形-只需将它们全部保留在一起。

你所做的不是一个合适的星形算法

Collections.sort(successors);

for (Node n1 : successors) {
  if (n.fSum() > n1.fSum()) {
    exploreList.remove(n);
    exploreList.add(n1);
  }      
}

你不应该这么做。在一个明星中，你总是考虑所有的继任者。你不必担心这个顺序——优先级队列会处理这个问题。但是，增加这一行你就增加了算法的复杂度。

Collections.sort(successors);

for (Node n1 : successors) {
  if (n.fSum() > n1.fSum()) {
    exploreList.remove(n);
    exploreList.add(n1);
  }      
}

---

这是完全错误的。你在这里做的是：你只添加所有继任者中最接近的一个。这将是一个大小为1的光束，而不是一个星-只需将它们全部保留在里面。

你的启发式函数是什么？它是

n.fSum（）

？public int fSum（）{return travDist+strighdist；}你的启发式函数是什么？它是

n.fSum（）

？public int fSum（）{return travDist+strighdist；}@SohaibMushtaq：如果我帮你解决了你的问题，别忘了投票/接受。是的，伙计，我正在尝试，但它告诉我我需要15个信誉点。@SohaibMushtaq哈，没关系，你会在一段时间内得到它。你仍然可以接受答案，尽管单击检查。Accpets会引导其他用户找到真正为你解决问题的方法。实际上我再次检查，它没有工作。（我调用了另一个搜索函数，但忘记了更改）。我注释掉了Collections.sort（继任者）和exploreList.remove（n）行；这就是我要做的，对吗？@SohaibMushtaq删除我引用的整个for循环。你在

节点中实际存储了什么？

？我实际上没有看到你计算增广路径……你能在问题中包含类的定义吗？@SohaibMushtaq：如果我帮你解决你的问题，别忘了向上投票/接受问题。是的，老兄，我正在尝试，但它告诉我我需要15个信誉点。@SohaibMushtaq哈哈，没关系，你会在一段时间内得到它。你仍然可以接受答案，尽管单击检查。Accpets会引导其他用户找到真正为你解决问题的方法。事实上，我再次检查，但它不起作用。（我调用了另一个搜索函数忘记更改）。我注释掉了Collections.sort（继任者）和exploreList.remove（n）行；这就是我要做的，对吗？@SohaibMushtaq删除我引用的整个for循环。你在

节点中实际存储了什么？

？我实际上没有看到你计算扩展路径……你能在问题中包括类的定义吗？