使用HashMap進行廣度優先搜索 <Vertex, List<Vertex> &gt;

Question

我正在嘗試在大圖上執行廣度優先搜索。 我有一個與每個鄰居相鄰的頂點的列表。 我已將數據放入哈希圖中，其中鍵為頂點，值為與鍵相鄰的頂點列表。 我已經嘗試了以下方法，但是由於我使用“鍵/值”對進行循環的方式，第二個“ For循環”將無限期運行。 但是我想不出另一種方法來正確循環並命中每個節點。

public static void BFS(HashMap<Vertex, List<Vertex>> map) {
        Queue<Vertex> myQ = new LinkedList<Vertex>();
        for(HashMap.Entry<Vertex, List<Vertex>> entry : map.entrySet()) {
            if(entry.getKey().getCount() == 0){
                count++;
                entry.getKey().setCount(count);
                myQ.add(entry.getKey());
                while(!myQ.isEmpty()) {
                    for(Vertex neighbor : entry.getValue()){
                        if(neighbor.getCount() == 0) {
                            count++;
                            neighbor.setCount(count);
                            myQ.add(neighbor);
                        }
                    }
                    myQ.remove(entry.getKey());
                }                   
            }       
        }
    }

count屬性用於跟蹤是否已訪問頂點。

任何幫助將不勝感激，只需要尋找一種新的方式思考如何遍歷HashMap。 或者，如果我做的事情完全錯誤:)

Answer 1

如果我理解您的問題和示例代碼，那么您要做的就是遍歷所有地圖的值，而不必多次訪問頂點。 如果是這樣，那么您可以使用Java 8執行以下操作：

map.values().stream().flatMap(List::stream).distinct()
    .forEach(vertex -> {...});

但是，如果您想從根節點開始並執行廣度優先搜索（這是正常機制），那么它會更復雜一些：

List<Vertex> completedList = new ArrayList<>();
for (List<Vertex> searchList = Arrays.toList(root);
    !searchList.isEmpty();
    searchList = searchList.stream().map(map::get).flatMap(List::steam)
        .filter(v -> !completedList.contains(v))
        .collect(Collectors.toList())) {
    searchList.forEach(vertex -> {...});
    completedList.addAll(searchList);
}

Answer 2

假設Vertex根開始搜索，您的代碼可能類似於：

public static void BFS(Vertex root, HashMap<Vertex, List<Vertex>> map) {
    Deque<Vertex> myQ = new LinkedList<Vertex>();
    myQ.add(root);
    while(!myQ.empty()) {
        Vertex current = myQ.getFirst();
        current.visited = true;
        // Or you can store a set of visited vertices somewhere
        List<Vertex> neighbors = map.get(current);
        for (Vertex neighbor : neighbors) {
            if (!neighbor.visited) {
                myQ.addLast(neighbor);
            }
        }
    }
}

Answer 3

在這里，我還沒有真正嘗試過這個代碼，因此它可能甚至不會按原樣進行編譯，但要讓它工作起來並不困難。 實際上，它應該使您對算法的工作原理有一個很好的了解。

public void BFS( HashMap<Vertex, List<Vertex>> map )
{
    if( map.isEmpty() )
        return;

    /* pick an arbitrary first vertex to start from */
    Vertex start = null;
    for( Vertex temp : map.getKeys() )
    {
         start = temp;
         break;
    }

    /* visit first vertex */
    visit( start );

    /* start recursion */
    BFS( start, map );
}

public void BFS( Vertex start, HashMap<Vertex, List<Vertex>> map )
{
    /* mark the current vertex as visited */
    int count = start.getCount();
    assert count == 0;
    count++;
    start.setCount( count );

    /* visit each unvisited neighboring vertex */
    for( Vertex neighbor : map.get( start ) ) 
    {
        if( neighbor.getCount() != 0 )
            continue;
        visit( neighbor );
    }

    /* recurse into each unvisited neighboring vertex */
    for( Vertex neighbor : map.get( start ) ) 
    {
        if( neighbor.getCount() != 0 )
            continue;
        BFS( neighbor, map );
    }
}

但是，在繼續進行此操作之前，我強烈建議您定義一個新的Graph類，封裝頂點圖，並提供在圖形術語而非Java集合術語中有意義的操作。