Question

我正在使用图形数据结构制作Hunt the Wumpus游戏。它的每个顶点是一个大小为4的数组，代表每个方向，即北东南西。方向存储在枚举中。当一个顶点与另一个顶点相连时，它的邻接关系应该发生变化，以便与另一个顶点相连（我对此仍然感到困惑-为什么我的顶点是一个大小为4的数组，但只有1个方向）。

当我将一个顶点连接到另一个顶点并打印出邻居的数组列表时，我得到一个奇怪的输出。当我打印未连接的顶点时，邻居会得到[null，null，null，null]。当我打印连接的顶点时，我得到[null，null，null，[null，null，null，null]。我不知道邻居应该是什么-他们应该以表示方向枚举索引或方向的整数形式打印出来吗？应该打印什么？

import java.util.ArrayList;
import java.util.Collection;

 enum Direction{
    EAST,
    WEST,
    NORTH,
    SOUTH
}
public class Vertex extends Agent implements Comparable<Vertex>{
    private Vertex[] connections;
    private Direction dir;
    private int cost;
    private boolean marked;


    public Vertex(double x0, double y0){
        super( x0,  y0);
        connections = new Vertex[4];
        this.dir = dir;
        this.cost = cost;
        this.marked = marked;
    }

    public Direction opposite(Direction dir) {
    //that returns the compass opposite of a direction (i.e. South for North...)
        if(dir == Direction.EAST){
            dir = Direction.WEST;
        }
        else if(dir == Direction.WEST){
            dir = Direction.EAST;
        }
        else if(dir == Direction.NORTH){
            dir = Direction.SOUTH;
        }
        else dir = Direction.NORTH;

        return dir;
    }
    void connect(Vertex other, Direction dir){
    //modify the object's adjacency list/map so that it connects with the other Vertex. This is a uni-directional link.
        connections[dir.ordinal()] = other;

        }

    Vertex getNeighbor(Direction dir){
    //returns the Vertex in the specified direction or null.
        return this.connections[dir.ordinal()];
        }

    Collection getNeighbors(){
    //returns a Collection, which could be an ArrayList, of all of the object's neighbors.
        ArrayList<Vertex> neighborList = new ArrayList<Vertex>();
            for (Direction dir: Direction.values()){
                neighborList.add(this.getNeighbor(dir));
            }

            return neighborList;
        }

    public int getCost(){
        return this.cost;
    }

    public int setCost(int c){
        return this.cost = c;
    }

    public boolean getMarked(){
        return this.marked;
    }

    public boolean setMarked(boolean m){
        return this.marked = m;
    }

    public int compareTo(Vertex other){
        return (this.cost - other.cost);
    }

    /*
    * returns a string containing the number of neighbors, the cost, and the marked flag
    */
    public String toString(){
        String s = "";
        s += this.getNeighbors() + "\n" ;
        s += "cost: " + this.cost + "\n";
        s += "marked: " + this.marked;
        return s;

    }

    public static void main (String args[]){
        Vertex newE = new Vertex(0.5, 0.5);
        Vertex newerE = new Vertex(0.123, 1.56);
        newE.connect(newerE, Direction.SOUTH);
        newE.setCost(1);
        newE.setMarked(true);
        System.out.println(newE.toString());
    }

}

Answer 1

好吧，当您获得输出[null，null，null，[null，null，null，null]]时，您知道存在对已连接节点的引用。因此，第二个阵列由第一个阵列连接，反之则不然。因为您的代码没有连接第二个节点，但是第一个已连接，我认为您不应该打印节点列表，这会导致问题。

在一种情况下，节点连接在一起，因此将父级连接到子级，并将子级连接到父级。现在打印出来时，您将获得递归执行。

[null，null，null，child [parent [[null，null，null，child [...]]]，null，null，null]]

这将导致异常。您可以为此使用标识符，例如ID。因此，您只需打印出所连接对象的ID，或者打印出位置->

[1，null，null，2]

[（x，y），（x，y），（x，y），（x，y）]

只需使用一些东西来标识节点，之后您就可以轻松查看该节点是否存在或为空。

另一点是，您知道要连接4个点，所以为什么不使用：

private Node north;
private Node south;
private Node west;
private Node east;

以后将更容易使用，并且您不必再使用此枚举。而且，您也可以删除Vertex类中的方向，这样也会使Vertex是一个点，而点没有方向：）

或者您仅为此使用2x2网格，例如：

private Node[][]

您可以通过知道要访问邻居的位置来指定网格的大小。例如，坐标[1,1]由[0,1]，[1,0]，[2,1]，[1,2]连接。而且，您还可以轻松打印出整个网格。

您可以将此计算放入算法中，以检查邻居。因此，您不必在每个节点类中都保存节点。例如，可以通过访问此对象获得渲染位置（仅当您要渲染它时）：

node[1][2].getX();

我也建议您看看树形结构：）

我怎么知道我的顶点有连接？

1 个答案: