Java实现邻接表存储图并实现深度优先遍历算法和广度优先遍历算法

Java实现邻接表存储图并实现深度优先算法和广度优先算法

1、结点类：
成员说明：
① edgeNodeList：与该结点相连的结点
②name：该结点名字
③isVisited：是否被访问过，默认是否

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;
    }
}

2、具体算法类
方法说明：
①public void insertNode(String n1,String n2)：向图插入结点，两个参数即两个结点名字代表这两个结点相连通
②public void getNodeMap()：获取创建完图后的邻接表
③public void dfs(String firstEdgeNodeName)：深度优先遍历，参数为开始遍历的第一个结点
④public void bfs(String firstEdgeNodeName)：广度优先遍历，参数为开始遍历的第一个结点

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);
        }
    }
}
``	`
**3、测试类**
这里要输入的图为
![在这里插入图片描述](https://img-blog.csdnimg.cn/20210423224217138.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L215bWlj,size_16,color_FFFFFF,t_70#pic_center)


```java
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.getNodeMap();

        System.out.println();
        System.out.println("-------");
        //输入第一个访问的结点名字
        System.out.print("深度优先遍历：");
        t.dfs("V1");

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

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

结果

邻接表如下：
V6->V3->V7
V7->V3->V6
V8->V4->V5
V1->V2->V3
V2->V1->V5->V4
V3->V1->V6->V7
V4->V2->V8
V5->V2->V8

-------
深度优先遍历：V1->V2->V5->V8->V4->V3->V6->V7->
-------
广度优先遍历：V1->V2->V3->V5->V4->V6->V7->V8->