图的遍历（Java）构造器

最新推荐文章于 2024-06-03 20:25:24 发布
最新推荐文章于 2024-06-03 20:25:24 发布
阅读量197 收藏
点赞数
分类专栏： Data Structure
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43511405/article/details/105002105
版权

图的遍历

一、DFS（Depth First Search）
![在这里插入图片描述](https://img-blog.csdnimg.cn/20200321001951462.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0c
概念：
从初始访问点出发，访问其第一个邻接节点；然后把这个邻接节点作为初始节点，继续访问它的第一个邻接节点。

即每次都在访问完当前节点过后，访问它的第一个邻接节点。

算法：

  1. 访问初始节点v（下标），并标记v已被访问；
  2. 查找节点v的第一个邻接节点w（下标）；
  3. 如果w存在，则继续4步骤；如果w不存在，则返回1步骤；
  4. 如果w未被访问过，对w进行dfs递归操作（重复1、2、3操作）；
  5. 查找节点v的w邻接节点的下一个邻接节点，返回3步骤

源代码如下：

import java.util.ArrayList;
import java.util.Arrays;

public class graph {

	private ArrayList<String> vertexList;// 定义顶点列表
	private int[][] edges;// 存储图对应的邻接矩阵
	private int numOfEdges;// 存储边
	private boolean isVisited[];// 标记顶点是否已被访问

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		// 测试图
		int n = 5;// 定义顶点个数
		String vertexs[] = { "A", "B", "C", "D", "E" };
		// 创建图对象
		graph graph = new graph(n);
		// 循环添加顶点
		for (String vertex : vertexs) {// 每次循环从vertexValue取出来一个值（定义为value）
			graph.insertVertex(vertex);// 把顶点加进去
		}
		// 添加边
		// A-B A-C B-C B-D B-E
		// 权值默认为是1
		graph.insertEdges(0, 1, 1);// A-B
		graph.insertEdges(0, 2, 1);// A-C
		graph.insertEdges(1, 2, 1);// B-C
		graph.insertEdges(1, 3, 1);// B-D
		graph.insertEdges(1, 4, 1);// B-E
		// 显示邻接矩阵
		graph.show();

		// DFS
		graph.dfs();

	}

	// ————————————--------------------------------------------------------
	// 首先定义图的属性
	// 1.构造器
	public graph(int n) {// 首先要传入顶点的数目
		// 初始化矩阵和vertexList
		edges = new int[n][n];
		vertexList = new ArrayList<String>();// 初始化顶点列表
		numOfEdges = 0;// 可省略，因为默认为0
		isVisited = new boolean[5];

	}

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

	// 3.设置边
	/**
	 * 
	 * @param v1     第一个顶点的下标
	 * @param v2     第二个顶点的下标
	 * @param weight 权值
	 */
	public void insertEdges(int v1, int v2, int weight) {
		// 这里是定义无向图，所以两个方向都要定义
		edges[v1][v2] = weight;
		edges[v2][v1] = weight;
		numOfEdges++;
	}

	// 4.返回顶点个数
	public int getnumOfVertexs() {
		return vertexList.size();
	}

	// 5.返回边个数
	public int getnumOfEdges() {
		return numOfEdges;
	}

	// 6.返回顶点i（顶点的下标）的对应的数据
	/**
	 * 
	 * @param i返回数据下标
	 * @return 返回数据 例：0->A 1->B 2->C 3->D 4->E
	 */
	public String getValueByIndex(int i) {
		return vertexList.get(i);
	}

	// 7.返回v1,v2两顶点之间的权值
	public int getWeight(int v1, int v2) {
		return edges[v1][v2];
	}

	// 8.打印邻接矩阵（本质：遍历图）
	public void show() {
		for (int[] link : edges) {
			System.out.println(Arrays.toString(link));
		}
	}
//————————————--------------------------------------------------------	

	// DFS算法步骤

	// 1.得到第一个邻接节点下标w
	/**
	 * 
	 * @param index
	 * @return 如果存在就返回它的下标，没有就返回-1
	 */
	public int getFirstNerghborIndex(int index) {// 传入当前节点的下标index
		for (int w = 0; w < vertexList.size(); w++) {
			if (edges[index][w] > 0) {// 如果下一个邻接节点存在
				return w;// 返回它的下标
			}
		}
		return -1;// 没有返回就返回-1
	}

	// 2.根据前一个邻接节点的下标来获取下一个邻接节点
	/**
	 * 
	 * @param v1
	 * @param v2
	 * @return
	 */
	public int getNextNeighbor(int v1, int v2) {
		for (int w = v2 + 1; w < vertexList.size(); w++) {
			if (edges[v1][w] > 0) {
				return w;
			}
		}
		return -1;
	}

	// 3.开始深搜遍历
	public void dfs(boolean[] isVisited, int i) {// 判断是否遍历过的标记，定义节点下标
		// 首先访问当前节点，输出
		System.out.print(getValueByIndex(i) + "->");
		// 访问过后，要标记节点已访问
		isVisited[i] = true;
		// 查找节点i的第一个邻接节点
		int w = getFirstNerghborIndex(i);
		while (w != -1) {// 存在
			if (!isVisited[w]) {// 如果没有被标记过
				dfs(isVisited, w);// 以w为初始节点重新开始，递归操作dfs
			}
			// 如果已经被访问过
			w = getNextNeighbor(i, w);
		}
	}

	// 对dfs进行重载，遍历所有节点
	public void dfs() {
		for (int i = 0; i < getnumOfVertexs(); i++) {
			while (!isVisited[i]) {// 如果没被访问过
				dfs(isVisited, i);
			}
		}
	}
}

二、BFS（Broad First Search）

.addLast()获取最后一个节点

在这里插入图片描述
概念：
类似一个分层搜索过程，BFS需要一个队列以保持访问过节点的顺序，以便按照这个顺序来访问他们的邻接节点。

算法：

  1. 访问初始节点v，并将其标记已经访问；
  2. 把节点v加入队列；
  3. 当队列非空时，继续执行，否则算法结束；
  4. 出队列，取得队头结点u；
  5. 查找初始节点也是队头结点u第一个邻接节点w；
  6. 若节点u的第一个邻接节点w不存在，执行步骤3，否则循环执行下述三个操作：
    （1）若节点w未被访问，访问它并标记已经访问；
    （2）节点w入队列；
    （3）查找节点u的继w邻接节点后的下一个邻接节点，转到步骤6。

源代码如下：

import java.util.ArrayList;
import java.util.Arrays;
import java.util.LinkedList;

public class graph {

	private ArrayList<String> vertexList;// 定义顶点列表
	private int[][] edges;// 存储图对应的邻接矩阵
	private int numOfEdges;// 存储边
	private boolean isVisited[];// 标记顶点是否已被访问

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		// 测试图
		int n = 5;// 定义顶点个数
		String vertexs[] = { "A", "B", "C", "D", "E" };
		// 创建图对象
		graph graph = new graph(n);
		// 循环添加顶点
		for (String vertex : vertexs) {// 每次循环从vertexValue取出来一个值（定义为value）
			graph.insertVertex(vertex);// 把顶点加进去
		}
		// 添加边
		// A-B A-C B-C B-D B-E
		// 权值默认为是1
		graph.insertEdges(0, 1, 1);// A-B
		graph.insertEdges(0, 2, 1);// A-C
		graph.insertEdges(1, 2, 1);// B-C
		graph.insertEdges(1, 3, 1);// B-D
		graph.insertEdges(1, 4, 1);// B-E
		// 显示邻接矩阵
		graph.show();
		/*// DFS
		System.out.println();
		System.out.println("DFS：");
		graph.dfs();
        */
		System.out.println();
		System.out.println();
		System.out.println("BFS：");
		graph.bfs();

	}

	// ————————————--------------------------------------------------------
	// 首先定义图的属性
	// 1.构造器
	public graph(int n) {// 首先要传入顶点的数目
		// 初始化矩阵和vertexList
		edges = new int[n][n];
		vertexList = new ArrayList<String>();// 初始化顶点列表
		numOfEdges = 0;// 可省略，因为默认为0
		isVisited = new boolean[vertexList.size() + 1];

	}

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

	// 3.设置边
	/**
	 * 
	 * @param v1     第一个顶点的下标
	 * @param v2     第二个顶点的下标
	 * @param weight 权值
	 */
	public void insertEdges(int v1, int v2, int weight) {
		// 这里是定义无向图，所以两个方向都要定义
		edges[v1][v2] = weight;
		edges[v2][v1] = weight;
		numOfEdges++;
	}

	// 4.返回顶点个数
	public int getnumOfVertexs() {
		return vertexList.size();
	}

	// 5.返回边个数
	public int getnumOfEdges() {
		return numOfEdges;
	}

	// 6.返回顶点i（顶点的下标）的对应的数据
	/**
	 * 
	 * @param i返回数据下标
	 * @return 返回数据 例：0->A 1->B 2->C 3->D 4->E
	 */
	public String getValueByIndex(int i) {
		return vertexList.get(i);
	}

	// 7.返回v1,v2两顶点之间的权值
	public int getWeight(int v1, int v2) {
		return edges[v1][v2];
	}

	// 8.打印邻接矩阵（本质：遍历图）
	public void show() {
		for (int[] link : edges) {
			System.out.println(Arrays.toString(link));
		}
	}
//————————————--------------------------------------------------------	

	// DFS算法步骤

	// 1.得到第一个邻接节点下标w
	/**
	 * 
	 * @param index
	 * @return 如果存在就返回它的下标，没有就返回-1
	 */
	public int getFirstNerghborIndex(int index) {// 传入当前节点的下标index
		for (int w = 0; w < vertexList.size(); w++) {
			if (edges[index][w] > 0) {// 如果下一个邻接节点存在
				return w;// 返回它的下标
			}
		}
		return -1;// 没有返回就返回-1
	}

	// 2.根据前一个邻接节点的下标来获取下一个邻接节点
	/**
	 * 
	 * @param v1为前驱点
	 * @param v2为前驱点的当前邻接节点
	 * @return
	 */
	public int getNextNeighbor(int v1, int v2) {
		for (int w = v2 + 1; w < vertexList.size(); w++) {
			if (edges[v1][w] > 0) {
				return w;
			}
		}
		return -1;
	}

	// 3.开始深搜遍历
	private void dfs(boolean[] isVisited, int i) {// 判断是否遍历过的标记，定义节点下标
		// 首先访问当前节点，输出
		System.out.print(getValueByIndex(i) + "->");
		// 访问过后，要标记节点已访问
		isVisited[i] = true;
		// 查找节点i的第一个邻接节点
		int w = getFirstNerghborIndex(i);
		while (w != -1) {// 存在
			if (!isVisited[w]) {// 如果没有被标记过
				dfs(isVisited, w);// 以w为初始节点重新开始，递归操作dfs
			}
			// 如果已经被访问过
			// 以u为前驱点，找w的下一个邻接节点
			// w为辅助变量，每次进行此操作的时候更新值
			w = getNextNeighbor(i, w);
		}
	}

	// 对dfs进行重载，遍历所有节点
	public void dfs() {
		for (int i = 0; i < getnumOfVertexs(); i++) {
			while (!isVisited[i]) {// 如果没被访问过
				dfs(isVisited, i);
			}
		}
	}

	// ————————————--------------------------------------------------------
	// BFS算法步骤
	private void bfs(boolean[] isVisited, int i) {
		int u;// 初始节点，队头结点
		int w;// 邻接节点
		// 使用队列记录访问节点的顺序
		LinkedList queue = new LinkedList();
		// 访问节点（输出节点信息）
		System.out.print(getValueByIndex(i) + "->");
		 标记为已访问
		isVisited[i] = true;
		// 若已访问，添加节点到队列
		queue.addLast(i);

		// 重复操作
		while (!queue.isEmpty()) {// 如果队列不为空
			// 取出队列的头节点下标
			u = (Integer) queue.removeFirst();
			// 得到第一个邻接节点的下标w
			w = getFirstNerghborIndex(u);
			while (w != -1) {// 找到邻接节点
				// 判断是否访问过
				if (!isVisited[w]) {// 如果没有访问过
					System.out.print(getValueByIndex(w) + "->");// 访问
					isVisited[w] = true;// 标记为已访问
					// 邻接节点入队列
					queue.addLast(w);
				}
				// 以u为前驱点，访问w的下一个邻接节点
				w = getNextNeighbor(u, w);
			}
		}
	}

	// 对bfs进行重载，遍历所有节点
	public void bfs() {
		for (int i = 0; i < getnumOfVertexs(); i++) {
			while (!isVisited[i]) {// 如果没被访问过
				bfs(isVisited, i);
			}
		}
	}
}

如果要同时显示DFS和BFS遍历结果，需将构造器中的初始化部分摘出来，分别放到DFS和BFS的重载方法里，每次调用时重新分配，就不会出现执行完一种遍历无法执行第二种遍历的情况。

代码如下：

import java.util.ArrayList;
import java.util.Arrays;
import java.util.LinkedList;

public class graph {

	private ArrayList<String> vertexList;// 定义顶点列表
	private int[][] edges;// 存储图对应的邻接矩阵
	private int numOfEdges;// 存储边
	private boolean isVisited[];// 标记顶点是否已被访问

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		// 测试图
		int n = 5;// 定义顶点个数
		String vertexs[] = { "A", "B", "C", "D", "E" };
		// 创建图对象
		graph graph = new graph(n);
		// 循环添加顶点
		for (String vertex : vertexs) {// 每次循环从vertexValue取出来一个值（定义为value）
			graph.insertVertex(vertex);// 把顶点加进去
		}
		// 添加边
		// A-B A-C B-C B-D B-E
		// 权值默认为是1
		graph.insertEdges(0, 1, 1);// A-B
		graph.insertEdges(0, 2, 1);// A-C
		graph.insertEdges(1, 2, 1);// B-C
		graph.insertEdges(1, 3, 1);// B-D
		graph.insertEdges(1, 4, 1);// B-E
		// 显示邻接矩阵
		graph.show();
		// DFS
		System.out.println();
		System.out.println("DFS：");
		graph.dfs();
		System.out.println();
		System.out.println();
		System.out.println("BFS：");
		graph.bfs();

	}

	// ————————————--------------------------------------------------------
	// 首先定义图的属性
	// 1.构造器
	public graph(int n) {// 首先要传入顶点的数目
		// 初始化矩阵和vertexList
		edges = new int[n][n];
		vertexList = new ArrayList<String>();// 初始化顶点列表
		numOfEdges = 0;// 可省略，因为默认为0

	}

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

	// 3.设置边
	/**
	 * 
	 * @param v1     第一个顶点的下标
	 * @param v2     第二个顶点的下标
	 * @param weight 权值
	 */
	public void insertEdges(int v1, int v2, int weight) {
		// 这里是定义无向图，所以两个方向都要定义
		edges[v1][v2] = weight;
		edges[v2][v1] = weight;
		numOfEdges++;
	}

	// 4.返回顶点个数
	public int getnumOfVertexs() {
		return vertexList.size();
	}

	// 5.返回边个数
	public int getnumOfEdges() {
		return numOfEdges;
	}

	// 6.返回顶点i（顶点的下标）的对应的数据
	/**
	 * 
	 * @param i返回数据下标
	 * @return 返回数据 例：0->A 1->B 2->C 3->D 4->E
	 */
	public String getValueByIndex(int i) {
		return vertexList.get(i);
	}

	// 7.返回v1,v2两顶点之间的权值
	public int getWeight(int v1, int v2) {
		return edges[v1][v2];
	}

	// 8.打印邻接矩阵（本质：遍历图）
	public void show() {
		for (int[] link : edges) {
			System.out.println(Arrays.toString(link));
		}
	}
//————————————--------------------------------------------------------	

	// DFS算法步骤

	// 1.得到第一个邻接节点下标w
	/**
	 * 
	 * @param index
	 * @return 如果存在就返回它的下标，没有就返回-1
	 */
	public int getFirstNerghborIndex(int index) {// 传入当前节点的下标index
		for (int w = 0; w < vertexList.size(); w++) {
			if (edges[index][w] > 0) {// 如果下一个邻接节点存在
				return w;// 返回它的下标
			}
		}
		return -1;// 没有返回就返回-1
	}

	// 2.根据前一个邻接节点的下标来获取下一个邻接节点
	/**
	 * 
	 * @param v1
	 * @param v2
	 * @return
	 */
	public int getNextNeighbor(int v1, int v2) {
		for (int w = v2 + 1; w < vertexList.size(); w++) {
			if (edges[v1][w] > 0) {
				return w;
			}
		}
		return -1;
	}

	// 3.开始深搜遍历
	private void dfs(boolean[] isVisited, int i) {// 判断是否遍历过的标记，定义节点下标
		// 首先访问当前节点，输出
		System.out.print(getValueByIndex(i) + "->");
		// 访问过后，要标记节点已访问
		isVisited[i] = true;
		// 查找节点i的第一个邻接节点
		int w = getFirstNerghborIndex(i);
		while (w != -1) {// 存在
			if (!isVisited[w]) {// 如果没有被标记过
				dfs(isVisited, w);// 以w为初始节点重新开始，递归操作dfs
			}
			// 如果已经被访问过
			w = getNextNeighbor(i, w);
		}
	}

	// 对dfs进行重载，遍历所有节点
	public void dfs() {
		isVisited = new boolean[5];
		for (int i = 0; i < getnumOfVertexs(); i++) {
			while (!isVisited[i]) {// 如果没被访问过
				dfs(isVisited, i);
			}
		}
	}

	// ————————————--------------------------------------------------------
	// BFS算法步骤
	private void bfs(boolean[] isVisited, int i) {
		int u;// 初始节点，队头结点
		int w;// 邻接节点
		// 使用队列记录访问节点的顺序
		LinkedList queue = new LinkedList();
		// 访问节点（输出节点信息）
		System.out.print(getValueByIndex(i) + "->");
		 标记为已访问
		isVisited[i] = true;
		// 若已访问，添加节点到队列
		queue.addLast(i);

		// 重复操作
		while (!queue.isEmpty()) {// 如果队列不为空
			// 取出队列的头节点下标
			u = (Integer) queue.removeFirst();
			// 得到第一个邻接节点的下标w
			w = getFirstNerghborIndex(u);
			while (w != -1) {// 找到邻接节点
				// 判断是否访问过
				if (!isVisited[w]) {// 如果没有访问过
					System.out.print(getValueByIndex(w) + "->");// 访问
					isVisited[w] = true;// 标记为已访问
					// 邻接节点入队列
					queue.addLast(w);
				}
				// 以u为前驱点，访问w的下一个邻接节点
				w = getNextNeighbor(u, w);
			}
		}
	}

	// 对bfs进行重载，遍历所有节点
	public void bfs() {
		isVisited = new boolean[5];
		for (int i = 0; i < getnumOfVertexs(); i++) {
			while (!isVisited[i]) {// 如果没被访问过
				bfs(isVisited, i);
			}
		}
	}
}
TYP_MOON
关注
专栏目录
java数组遍历 删除remove(示例代码)
09-04
这个类有两个构造方法，一个无参构造器和一个带参数的构造器，用于初始化对象。 然后，创建了`Core2`类的几个实例，并将它们添加到一个ArrayList类型的`aa`集合中。ArrayList是Java中的一个动态数组，它可以自动...
图的遍历（深度优先，广度优先）总结-java版
许诗宇的博客
05-22 4238
目录 图的遍历简介 广度优先搜索算法 算法的思想 算法实现的思想 算法的复杂度 深度优先搜索算法 算法的思想 算法实现的思想 算法的复杂度 java实现 图的基础java代码 广度优先算法 深度优先算法 测试 图的遍历简介 图的遍历是指从图中的任一顶点出发，对图中的所有顶点访问一次并且只访问一次。图的遍历是图的一种基本操作，图中的许多其他操作也都是建立在遍历的基础之...
Java实现图的遍历
wwb44444的博客
01-22 2288
最近又在手撕数据结构的代码，温习一遍得到了一些新的感悟。在这里全面地总结一下关于图的遍历算法逻辑，并手写Java代码实现，力图将全部实现逻辑呈现在读者面前。本文主要讲解的图的遍历算法为深度优先遍历与广度优先遍历。 一、图的实现 图的实现主要有两种方式，一种是邻接矩阵，一种是邻接表。 所谓邻接矩阵就是构建一个节点到节点的矩阵，每一行每一列都代表一个节点，矩阵的输入数据即为该位置所在的行和列对应的节点之间是否可达。一般而言，若该数值为表示不可达，为一个正数表示该条边的权值。矩阵对角线上的数值一般为0，表示
图的遍历（Java）
weixin_48544279的博客
09-10 1554
本篇文章主要是：简单的介绍了图相关的知识，并用java实现图的深度优先遍历和图的广度优先遍历。编译器使用的是IDEA。文中有详细教程地址。
Java学习——数据结构——图的遍历
qq_41853002的博客
05-30 269
1、图的遍历介绍 所谓图的遍历，即是对结点的访问。一个图有那么多个结点，如何遍历这些结点，需要特定策略，一般有两种访问策略: (1)深度优先遍历 (2)广度优先遍历 2、深度优先 2.1 基本思想 图的深度优先搜索(Depth First Search) 。 （1) 深度优先遍历，从初始访问结点出发，初始访问结点可能有多个邻接结点，深度优先遍历的策略就是首先访问第一个邻接结点，然后再以这个被访问的邻接结点作为初始结点，访问它的第一个邻接结点， 可以这样理解： 每次都在访问完当前结点后首先访问当前结点的第一个
Java图的遍历知识点（含面试大厂题和源码）
2302_80314137的博客
03-24 1194
图的遍历是图论中的一个基本概念，主要指的是按照某种规则，系统地访问图中的每一个顶点，且每个顶点仅被访问一次。图遍历的主要目的是为了搜索图中的信息或检查图中是否存在特定的路径或圈。图的遍历算法主要有两种：深度优先搜索（DFS）和广度优先搜索（BFS）。
java使用iterator遍历指定目录示例分享
09-04
在Java编程中，遍历指定目录以及其子文件是一个常见的任务，这通常涉及到对文件系统进行操作。在给定的示例中，我们看到使用了`Iterator`接口和`Iterable`接口来实现这一功能。下面将详细介绍这个示例中涉及的知识点...
java arrayList遍历的四种方法及Java中ArrayList类的用法
09-03
- `ArrayList(int initialCapacity)`：指定初始容量的构造器，确保ArrayList创建时有足够的空间。 4. **重要方法和属性**： - `add(E e)`：向ArrayList末尾添加一个元素。 - `remove(int index)`：删除指定索引...
Java实现的自定义迭代器功能示例
08-30
通过这个示例，我们可以了解到如何在Java中自定义迭代器，并使用它来遍历非标准集合（如自定义对象数组）。这有助于在特定场景下提高代码的灵活性和可扩展性。同时，这个例子也展示了Java 5和Java 8两种不同方式使用...
Java Set集合的遍历及实现类的比较
08-30
1. 迭代器（Iterator）遍历：这是最基础的遍历方式，通过调用`iterator()`方法获取迭代器，然后使用`hasNext()`和`next()`方法依次访问集合中的元素。例如： ```java for(Iterator<String> iterator = set.iterator...
Java图遍历算法一例
12-07
java图遍历应用一例： 题目：用1、2、2、3、4、5这六个数字，用java写一个函数，打印出所有不同的排列，如：512234、412345等，要求："4"不能在第三位，"3"与"5"不能相连。
图的深度和广度遍历（Java实现）
08-06
使用Java实现图的深度优先和广度优先遍历算法
Java实现图的深度优先遍历和广度优先遍历
12-28
图的深度优先遍历和广度优先遍历-Java实现
Java算法系列第二十篇：图遍历算法详解
最新发布
阿里渣渣java研发组-群主
06-03 922
图遍历算法是图算法中的基本操作，广泛应用于社交网络分析、搜索引擎、路径规划、网络安全和数据分析等领域。通过理解和掌握深度优先搜索（DFS）和广度优先搜索（BFS），可以解决许多实际问题，提高算法设计和编程能力。你的支持是我持续创作的动力！下期我们将详细讲解Java中的图算法应用，敬请期待！这篇文章详细介绍了图遍历的基本概念、实现方法及其应用场景。如果你有任何问题或建议，欢迎在评论区留言！
Java数据结构——图的遍历(DFS+BFS)
NoBug
02-18 1079
文章目录一、图例二、深度优先搜索遍历（一）、定义（二）、数据结构（三）、Java代码三、广度优先搜索遍历（一）、定义 一、图例 访问序列： - DFS: v1->v2->v4->v8->v5->v3->v6->v7 - BDS: v1->v2->v3->v4->v5->v6->v7->v8 二、深度优先搜索遍历 （一）、定义 特点： 单向前进，回路回退。 二叉树： 前序遍历，中序遍历，后序遍历。 图的遍历： 从图中某
图的遍历(Java语言)
qq_49306008的博客
12-10 1882
Java语言实现图的深度优先遍历和广度优先遍历
继承 初始化方法 遍历构造器
qiyuting_cherish的博客
09-07 449
继承: 1.单向继承,一个类只能有一个父类,一个父类可以有多个子类. 2.单向继承,基类(根类)是OSObject 3.子类可以继承父类的属性和方法   当父类的方法不满足子类的需求时,子类可以重写父类的方法,重写父类的方法,在子类中不需要再次声明. 1.完全重写 2.部分重写 使用super   建立继承关系之后,子类可以继承父类的:
java 集合之LinkedList 构造器 方法 遍历方法 listIterator
SKPrimin的博客
08-17 813
java 集合之LinkedList List 和 Deque 接口的双向链表实现。 实现所有可选的列表操作，并允许所有元素（包括空值）。 除了实现 List 接口外，LinkedList 类还为在列表的开头及结尾 get、remove 和 insert 元素提供了统一的命名方法。这些操作允许将链接列表用作堆栈、队列或双端队列。 实现 Deque 接口，为 add、poll 提供先进先出队列操作，以及其他堆栈和双端队列操作。 所有操作都是按照双重链接列表的需要执行的。在列表中编索引的操作将从开头
图 遍历 java_java中图的遍历
weixin_39971435的博客
02-12 92
/*class Queue {private int[] values;private int begin = -1;private int end = -1;Queue(int size) {values = new int[size];}void push(int value) {values[++begin] = value;}int pop() { return values[++end]...
使用java迭代器进行中序遍历
06-01
在Java中，可以使用迭代器实现二叉树的中序遍历。具体实现步骤如下： 1. 定义一个内部类`InorderIterator`，实现`Iterator`接口，并指定迭代器遍历的元素类型为`TreeNode`； 2. 在`InorderIterator`内部定义一个栈...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值