一研为定，万山无阻 ！

• 方法API 内含 BFS DFS 算法

题面

• 博主的图的操作是基于邻接表进行存储
• 当然还可以通过邻接矩阵进行存储

代码

构造函数

package AdjacencyList;

import java.util.LinkedList;

public class EdgeNode {

    //该结点所连接的其他结点
    private LinkedList<EdgeNode> edgeNodeList;
    //结点名称
    private String name;
    //初始阶段结点未被访问
    private boolean isVisited =false;

    public EdgeNode(String name) {
        this.name = name;
    }

    public LinkedList<EdgeNode> getEdgeNodeList() {
        return edgeNodeList;
    }

    public void setEdgeNodeList(LinkedList<EdgeNode> edgeNodeList) {
        this.edgeNodeList = edgeNodeList;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public boolean isVisited() {
        return isVisited;
    }

    public void setVisited(boolean visited) {
        isVisited = visited;
    }
}

方法API

package AdjacencyList;

import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.Map;



public class Solution {
    private HashMap<String,EdgeNode> nodeMap=new HashMap();
 
    //创建邻接表
    public void insertNode(String n1,String n2){
        EdgeNode edgeNode1 = nodeMap.get(n1);
        EdgeNode edgeNode2 = nodeMap.get(n2);
        if (edgeNode1==null) {
            edgeNode1 = new EdgeNode(n1);
            nodeMap.put(n1,edgeNode1);
        }	
        if (edgeNode2==null){
            edgeNode2 = new EdgeNode(n2);
            nodeMap.put(n2,edgeNode2);
        }
          LinkedList linkedList1=edgeNode1.getEdgeNodeList();
          LinkedList linkedList2=edgeNode2.getEdgeNodeList();
          if(linkedList1==null) {
              linkedList1 = new LinkedList();
          }
          if (linkedList2==null){
              linkedList2=new LinkedList();
          }
          linkedList1.addLast(edgeNode2);
          linkedList2.addLast(edgeNode1);
          edgeNode1.setEdgeNodeList(linkedList1);
          edgeNode2.setEdgeNodeList(linkedList2);
    }
    //获取邻接表并打印
    public void getNodeMap(){
        for (Map.Entry<String,EdgeNode> entry:nodeMap.entrySet()){
            System.out.print(entry.getKey());   
            Iterator<EdgeNode> iterator=entry.getValue().getEdgeNodeList().iterator();
            while (iterator.hasNext()){                             
                System.out.print("->"+iterator.next().getName());
            }
            System.out.println();
        }

    }

    //深度遍历图
    public void dfs(String firstEdgeNodeName){
        EdgeNode currentNode = nodeMap.get(firstEdgeNodeName);
        if (!currentNode.isVisited()) {
            //对结点进行相关操作
            System.out.print(currentNode.getName()+"->");
            //设置结点为已访问
            currentNode.setVisited(true);
            Iterator<EdgeNode> iterator = currentNode.getEdgeNodeList().iterator();
            while (iterator.hasNext()) {
                dfs(iterator.next().getName());
            }
        }
        else {
            return;
        }
    }

    //广度遍历图
    public void bfs(String firstEdgeNodeName){
        LinkedList<EdgeNode> queue=new LinkedList<>();
        queue.add(nodeMap.get(firstEdgeNodeName));
        while (!queue.isEmpty()){
            EdgeNode currentNode=queue.removeFirst();
            if (currentNode.isVisited()){
                continue;
            }
            System.out.print(currentNode.getName()+"->");
            currentNode.setVisited(true);
            for (EdgeNode sonNode: currentNode.getEdgeNodeList()){
                if (!sonNode.isVisited()){
                    queue.add(sonNode);
                }
            }
        }
    }
      //初始化访问结点，即设置所以结点都为未访问
    public void setVisit(){
        for (Map.Entry<String,EdgeNode> entry:nodeMap.entrySet()){
            entry.getValue().setVisited(false);
        }
    }
}

执行单元

package AdjacencyList;

import java.util.Scanner;

// 邻接表

public class Test {

    public static void main(String[] args) {

         //按上图插入结点
        Solution t=new Solution();
        t.insertNode("V1","V2");
        t.insertNode("V1","V3");
        t.insertNode("V6","V3");
        t.insertNode("V7","V3");
        t.insertNode("V6","V7");
        t.insertNode("V2","V5");
        t.insertNode("V2","V4");
        t.insertNode("V8","V4");
        t.insertNode("V8","V5");
        
        t.insertNode("V7", "V9");
        t.insertNode("V6","V10");
        //获取邻接表
        System.out.println("根据参数创建的邻接表如下");
        t.getNodeMap();

        System.out.println();
        System.out.println("-------");
        //输入第一个访问的结点名字
        
        System.out.println("请输入两种遍历方式的开始结点");
    
        
        Scanner sc = new Scanner(System.in) ;
        String str = sc.next() ; 
        
        System.out.print("深度优先遍历：");
        t.dfs(str);

        //重新设置未访问
        t.setVisit();

        System.out.println();
        System.out.println("-------");
        System.out.print("广度优先遍历：");
        t.bfs(str);
    }
}

结果

原文链接:https://blog.csdn.net/QuantumYou/article/details/117323964