图的创建，图的深度优先遍历和广度优先遍历

图

图的表现形式：
邻接矩阵：使用二维数组,行列表示各个顶点,使用规定的数来表示两个顶点之间是否存在边。
例如：

上面就是上面图的邻接矩阵，其中0代表无连接，1代表链接。

除了使用邻接矩阵，还可以使用邻接表表示，邻接表就是针对每一个顶点有一个链表，该链表指向了每一个可以链接的顶点。所有顶点的链表构成的数组。

JAVA构建图：

// 存储图的顶点
	private List<String> vertexList;
	// 邻接矩阵
	private int[][] edges;
	// 边的条数
	private int numOfEdges;
	// 标记顶点是否有被访问过
	private boolean[] isVisited;
	
	// 初始化一个n个顶点的图
	public Graph(int n) {
		edges = new int[n][n];
		vertexList = new ArrayList<String>(n);
	}
	
	/**
	 * 添加图的边
	 * 
	 * @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 void insertVertex(String vertex) {
		vertexList.add(vertex);
	}
	// 返回节点的个数
	public int getNumOfVertex() {
		return vertexList.size();
	}

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

	// 返回节点i对应的数据
	public String getValueByIndex(int i) {
		return vertexList.get(i);
	}

	// 返回v1 v2的权值
	public int getWeight(int v1, int v2) {
		return edges[v1][v2];
	}

这样只要创建对应的图就可以了，测试代码

Graph graph = new Graph(6);
		String[] vertexs = { "A", "B", "C", "D", "E" };
		for (String vertexValue : vertexs) {
			graph.insertVertex(vertexValue);
		}
		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);

图的深度优先遍历

直接例子说明：

图中0代表无直接链接，1代表直连。
以A顶点为起始顶点,输出该顶点，标记为已访问，遍历A行，找到它的第一个连接顶点，B，输出B，标记访问。在从B行开始遍历，找到第一个连接顶点A，但是A访问过了，在继续找下一个，找到C，C没有访问过，输出C，在从C行开始遍历，找到第一个链接顶点A，访问过，继续遍历，直到找到下一个没有访问过的，步骤同上面。如果遍历完后都没有找到，则退回到上一个顶点往下继续遍历…直到遍历结束。
JAVA代码：

/**
	 * 首先,需要准备一个查找第一个顶点连接顶点的方法
	 * 
	 * @param index 第一个顶点的下标
	 * @return 查找到的下标,-1代表不存在
	 */
	public int getFirstNeighbor(int index) {
		// 遍历该顶点的哪一行,一直找到不为0的那个下标
		for (int j = 0; j < vertexList.size(); j++) {
			if (edges[index][j] > 0) {
				return j;
			}
		}
		return -1;
	}
	/**
	 * 根据传入顶点的下标,找到传入下标的下一位连接顶点的下标
	 * @param v1 顶点下标
	 * @param v2 已经查找过的下标
	 * @return 查找到的顶点下标
	 */
	public int getNextNeighbor(int v1, int v2) {
		// v2传入的是已经处理过的下标,所以需要继续往它的下一位进行遍历
		for (int j = v2 + 1; j < vertexList.size(); j++) {
			if (edges[v1][j] > 0) {
				return j;
			}
		}
		return -1;
	}
	/**
	 * 深度优先遍历
	 * 
	 * @param isVisited 记录顶点是否访问过的数组
	 * @param i         进行遍历的顶点
	 */
	private void dfs(boolean[] isVisited, int i) {
		// 输出当前顶点,标记当前顶点访问过,获取当前顶点的下一个连接顶点
		System.out.print(getValueByIndex(i) + "->");
		isVisited[i] = true;
		int w = getFirstNeighbor(i);
		// 如果连接顶点的下标不为-1,一直循环
		while (w != -1) {
			// 是否访问过当前顶点
			if (!isVisited[w]) {
				// 没有访问过就把查找到的第一个顶点传进去,递归遍历
				dfs(isVisited, w);
			}
			// 如果访问过,就获取当前顶点的下一个链接顶点
			w = getNextNeighbor(i, w);
		}
	}

	/**
	 * 重载dfs方法,循环所有顶点,进行dfs方法,直到所有顶点全部遍历
	 */
	public void dfs() {
		isVisited = new boolean[vertexList.size()];
		// 遍历所有的结点
		for (int i = 0; i < getNumOfVertex(); i++) {
			if (!isVisited[i]) {
				dfs(isVisited, i);
			}
		}
	}

广度优先遍历

与深度优先不一样的是广度优先是先把当前顶点的所有链接顶点都访问结束后，在从访问过的顶点中挑选一个，继续找到它的所有链接顶点，直到所有顶点遍历完成。
步骤直接看代码：

/**
	 * 广度优先遍历
	 * 
	 * @param isVisited 标记访问过
	 * @param i 访问的顶点下标
	 */
	private void bfs(boolean[] isVisited, int i) {
		// 模拟的一个队列,用来记录访问过的顶点顺序
		LinkedList<Integer> queue = new LinkedList<>();
		// 输出当前顶点
		System.out.print(getValueByIndex(i) + "->");
		isVisited[i] = true;
		// 把顶点加入到模拟队列中
		queue.addLast(i);
		// 当模拟队列不为空时,一直循环
		while (!queue.isEmpty()) {
			// 取出模拟队列中的第一个顶点下标
			int u = queue.removeFirst();
			// 获取到该顶点的第一个链接顶点
			int w = getFirstNeighbor(u);
			// 当顶点下标一直存在时,一直循环
			while (w != -1) {
				// 如果当前顶点的第一个链接顶点没有被访问过
				if (!isVisited[w]) {
					// 输出当前顶点的下一个链接顶点
					System.out.print(getValueByIndex(w) + "->");
					isVisited[w] = true;
					// 在把这个顶点加入到模拟队列中
					queue.addLast(w);
				}
				// 获取当前顶点的下一个链接顶点,w的下一个
				w = getNextNeighbor(u, w);
			}
		}
	}
// 进行方法重置,同深度优先遍历
	public void bfs() {
		isVisited = new boolean[vertexList.size()];
		for (int i = 0; i < getNumOfVertex(); i++) {
			if (!isVisited[i]) {
				bfs(isVisited, i);
			}
		}
	}