图

基本介绍

图是一种数据结构，其中结点可以具有零个或多个相邻元素。两个结点之间的连接称为边。 结点也可以称为顶点。当我们需要表示多对多的关系时， 就用到了图。

常用概念

1）顶点(vertex)
2) 边(edge)
3) 路径
4）无向图（顶点之间的连接没有方向，比如A-B,即可以是 A-> B 也可以 B->A）

5）有向图（ 顶点之间的连接有方向，比如A-B,只能是 A-> B 不能是 B->A）
6）带权图

图的表示方式

1 邻接矩阵

邻接矩阵是表示图形中顶点之间相邻关系的矩阵。

2 邻接表

1）邻接矩阵需要为每个顶点都分配n个边的空间，其实有很多边都是不存在,会造成空间的一定损失。
2）邻接表的实现只关心存在的边，不关心不存在的边。因此没有空间浪费，邻接表由数组+链表组成。

代码

public class Graph {
  public static void main(String[] args) {
    Graph graph = new Graph(5);
    String[] vertexs = {"A", "B", "C", "D", "E"};
    for (String vertex : vertexs) {
      graph.insertVertex(vertex);
    }

    graph.insertEdge(0, 1, 1);
    graph.insertEdge(0, 2, 1);
    graph.insertEdge(1, 2, 1);
    graph.insertEdge(1, 3, 1);
    graph.insertEdge(1, 4, 1);
    graph.showGraph();
    System.out.println("深度优先");
    graph.dfs();
    System.out.println();
    System.out.println("广度优先");
    graph.bfs();
  }

  private final ArrayList<String> vertexList; //存储顶点

  private final int[][] edges;  //图对应的邻结矩阵

  private int numOfEdges; //边的个数

  private  boolean[] isVisited;

  public Graph(int n) {
    vertexList = new ArrayList<>(n);
    edges = new int[n][n];
    numOfEdges = 0;
  }

  //插入结点
  public void insertVertex(String vertex) {
    vertexList.add(vertex);
  }

  /**
   * 添加边
   * @param v1 第几个顶点
   * @param v2 第二个顶点对应的下标
   * @param weight 权值
   */
  public void insertEdge(int v1, int v2, int weight) {
    edges[v1][v2] = weight;
    edges[v2][v1] = weight;
    numOfEdges++;
  }

  //返回两个结点对应的值
  public int getWeight(int v1,int v2) {
    return edges[v1][v2];
  }

  //返回下标 index 对应的数据
  public String getValueByIndex(int index) {
    return vertexList.get(index);
  }

  //返回边的数量
  public int getNumOfEdges() {
    return numOfEdges;
  }

  //显示图对应的矩阵
  public void showGraph() {
    for (int[] edge : edges) {
      System.out.println(Arrays.toString(edge));
    }
  }

  //返回结点的个数
  public int getNumOfVertex() {
    return vertexList.size();
  }

  /**
   * @param index 第几个结点
   * @return 如果存在就返回对应的下标，否则返回-1
   */
  public int getFirstNeighbor(int index) {
    for (int i = 0; i < vertexList.size(); i++) {
      if (edges[index][i] > 0) {
        return i;
      }
    }
    return -1;
  }

  /**
   * 根据前一个邻接结点的下标来获取下一个邻接结点
   * @param v1 第几个结点
   * @param v2 邻接结点的下标
   * @return 找到就返回下标，否则返回-1
   */
  public int getNextNeighbor(int v1,int v2) {
    for (int i = v2 + 1; i < vertexList.size(); i++) {
      if (edges[v1][i] > 0) {
        return i;
      }
    }
    return -1;
  }

  //深度优先遍历算法
  private void dfs(boolean[] isVisited,int index) {
    System.out.print(getValueByIndex(index) + "==>");
    isVisited[index] = true;
    int firstNeighbor = getFirstNeighbor(index);
    while (firstNeighbor != -1) {
      if (!isVisited[firstNeighbor]) {
        dfs(isVisited,firstNeighbor);
      }
      firstNeighbor = getNextNeighbor(index,firstNeighbor);
    }
  }

  //对dfs进行重载，遍历所有结点
  public void dfs() {
    isVisited = new boolean[vertexList.size()];
    for (int i = 0; i < getNumOfVertex(); i++) {
      if (!isVisited[i]) {
        dfs(isVisited,i);
      }
    }
  }

  //对一个结点进行广度优先遍历
  private void bfs(boolean[] isVisited,int index) {
    int first;
    int w;
    System.out.print(getValueByIndex(index) + "==>");
    LinkedList<Integer> integers = new LinkedList<>();
    isVisited[index] = true;
    integers.addLast(index);
    while (!integers.isEmpty()) {
      first = integers.removeFirst();
      w = getFirstNeighbor(first);
      while (w != -1) {
        if (!isVisited[w]) {
          System.out.print(getValueByIndex(w) + "==>");
          isVisited[w] = true;
          integers.addLast(w);
        }
        w = getNextNeighbor(first,w);
      }
    }
  }

  //遍历所有的结点，都进行广度优先搜索
  public void bfs() {
    isVisited = new boolean[vertexList.size()];
    for (int i = 0; i < vertexList.size(); i++) {
      if (!isVisited[i]) {
        bfs(isVisited,i);
      }
    }
  }

}