数据结构学习（图）：邻接链表实现无向图

废话不多说，上代码：

package com.finn.algorithm.graph;

import java.util.LinkedList;
import java.util.Queue;

/**
 * 图存储结构
 * 邻接链表实现无向图
 */
public class ListUDG {
    //边的数据结构
    private class ENode {
        int adjvex;//数组下标
        ENode next; //下一个节点
    }

    //顶点数据结构
    private class VNode {
        String data;
        ENode firstNode; //第一个节点
    }

    private VNode[] mVexs; //顶点数组

    private boolean[] visit;//访问数组

    /**
     * 生成图
     * @param vexs 顶点数组
     * @param edges 边数组
     */
    public ListUDG(String[] vexs, String[][] edges) {
        //初始化顶点数和边数
        int vlen = vexs.length;
        int elen = edges.length;

        //初始化顶点数组
        mVexs = new VNode[vlen];
        //初始化访问数组
        visit = new boolean[mVexs.length];
        //初始化顶点
        for (int i = 0; i < vlen; i++) {
            mVexs[i] = new VNode();
            mVexs[i].data = vexs[i];
            mVexs[i].firstNode = null;
        }
        //初始化边
        for (int i = 0; i < elen; i++) {
            //{"A","B"} s1=A,s2=B
            String s1 = edges[i][0];
            String s2 = edges[i][1];

            //找到s1,s2下标
            int p1 = getPosition(s1,vexs);
            int p2 = getPosition(s2,vexs);

            //为s1生成邻接链表
            ENode eNode1 = new ENode();
            eNode1.adjvex = p2;
            eNode1.next=null;
            if (mVexs[p1].firstNode == null) {//该顶点还未有边
                mVexs[p1].firstNode = eNode1;
            } else {
                //头插法
                ENode temp = mVexs[p1].firstNode;
                eNode1.next = temp;
                mVexs[p1].firstNode = eNode1;
            }

            //因为是无向图，{"A","B"}。A既是B的连接点。B亦是A的连接点
            ENode eNode2 = new ENode();
            eNode2.adjvex = p1;
            eNode2.next=null;
            if (mVexs[p2].firstNode == null) {
                mVexs[p2].firstNode = eNode2;
            } else {
                //头插法
                ENode temp = mVexs[p2].firstNode;
                eNode2.next = temp;
                mVexs[p2].firstNode = eNode2;
            }
        }
    }

    /**
     * 获取顶点下标
     * @param s
     * @param vexs
     * @return
     */
    private int getPosition(String s,String[] vexs) {
        int i ;
        for (i = 0; i < vexs.length; i++) {
            if (vexs[i].equals(s))
                break;
        }
        return i;
    }

    /**
     * 获取顶点下标
     * 重载方法
     */
    private int getPosition(String s,VNode[] vexs) {
        int i ;
        for (i = 0; i < vexs.length; i++) {
            if (vexs[i].data.equals(s))
                break;
        }
        return i;
    }

    //打印图结构
    public void print(){
        for(int i = 0;i<mVexs.length;i++){
            System.out.print(i+" "+mVexs[i].data+":");
            ENode temp = mVexs[i].firstNode;
            while (temp!=null){
                System.out.print("->"+temp.adjvex+mVexs[temp.adjvex].data);
                temp = temp.next;
            }
            System.out.println();
        }
    }

    /**
     * 深度优先遍历
     */
    public void dfsGraph(){
        int len = mVexs.length;
        int i;
        for(i = 0;i<len;i++){
            visit[i] = false;//初始化都未访问过
        }
        for(i = 0;i<len;i++){
            if(!visit[i]){//连通图就只会执行一次
                DFS(mVexs[i],i);
            }
        }
    }

    private void DFS(VNode node , int i){
        System.out.println("访问的顶点为"+mVexs[i].data);
        visit[i] = true;
        ENode temp = node.firstNode;
        while (temp!=null){
            if(!visit[temp.adjvex]){
                DFS(mVexs[temp.adjvex],temp.adjvex);
            }
            temp = temp.next;
        }
    }

    /**
     * 广度优先遍历
     */
    public void bfsGraph(){
        int len = mVexs.length;
        //初始化visit数组
        for(int i = 0;i<len;i++){
            visit[i] = false;
        }
        for(int i = 0;i<len;i++){
            if(!visit[i]){
                BFS(mVexs[i]);
            }
        }
    }

    private void BFS(VNode node){
        Queue<VNode> queue = new LinkedList<>();
        queue.offer(node);
        while(!queue.isEmpty()){
            VNode temp = queue.poll();
            if(!visit[getPosition(temp.data,mVexs)]){
                System.out.println("访问的顶点为"+temp.data);
                visit[getPosition(temp.data,mVexs)] = true;
            }
            ENode eNode = temp.firstNode;
            while (eNode!=null){
                if(!visit[eNode.adjvex]){
                    queue.offer(mVexs[eNode.adjvex]);
                }
                eNode = eNode.next;
            }
        }
    }

    public static void main(String[] args) {
        String[] vexs = {"A", "B", "C", "D", "E", "F", "G"};
        String[][] edges = {{"A","B"},{"A","D"},{"B","C"},{"B","E"},{"C","G"},
                {"D","E"},{"D","F"},{"E","G"},{"F","G"}};
        ListUDG udg = new ListUDG(vexs,edges);
        udg.print();//打印图结构
        System.out.println("深度优先遍历======》");
        udg.dfsGraph();//深度优先遍历
        System.out.println("广度优先遍历======》");
        udg.bfsGraph();//广度优先遍历
    }
}

实现思想借鉴：
https://www.cnblogs.com/skywang12345/p/3707612.html