Java数据结构与算法（八）-多路查找树、图

最新推荐文章于 2022-06-25 18:02:16 发布
最新推荐文章于 2022-06-25 18:02:16 发布
阅读量274 收藏
点赞数
分类专栏： java 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37965402/article/details/118034186
版权

本章目录

第12章 多路查找树

12.1 二叉树与B树

12.1.1 二叉树的问题分析

在这里插入图片描述
二叉树需要加载到内存的，如果二叉树的节点少，没有什么问题，但是如果二叉树的节点很多(比如1 亿)， 就 存在如下问题:
（1）问题 1：在构建二叉树时，需要多次进行 i/o 操作(海量数据存在数据库或文件中)，节点海量，构建二叉树时，速度有影响
（2）问题 2：节点海量，也会造成二叉树的高度很大，会降低操作速度.

12.1.2 多叉树

  1. 在二叉树中，每个节点有数据项，最多有两个子节点。如果允许每个节点可以有更多的数据项和更多的子节点， 就是多叉树（multiway tree）
  2. 后面我们讲解的 2-3 树，2-3-4 树就是多叉树，多叉树通过重新组织节点，减少树的高度，能对二叉树进行优化。
    在这里插入图片描述

12.1.3 B树的基本介绍

B 树通过重新组织节点，降低树的高度，并且减少 i/o 读写次数来提升效率。
在这里插入图片描述

  1. 如图 B 树通过重新组织节点， 降低了树的高度.
  2. 文件系统及数据库系统的设计者利用了磁盘预读原理，将一个节点的大小设为等于一个页(页得大小通常为4k)，这样每个节点只需要一次 I/O 就可以完全载入
  3. 将树的度M 设置为 1024，在 600 亿个元素中最多只需要 4 次 I/O 操作就可以读取到想要的元素, B 树(B+)广泛应用于文件存储系统以及数据库系统中
    （1）节点的度：节点的子树的个数
    （2）树的度：树中节点的度中最大的度。

12.2 2-3树

12.2.1 2-3 树介绍

2-3 树是最简单的 B 树结构, 具有如下特点:
（1）2-3 树的所有叶子节点都在同一层.(只要是 B 树都满足这个条件)
（2）有两个子节点的节点叫二节点，二节点要么没有子节点，要么有两个子节点.
（3）有三个子节点的节点叫三节点，三节点要么没有子节点，要么有三个子节点.
（4）2-3 树是由二节点和三节点构成的树。

12.2.2 2-3树的应用案例

将数列{16, 24, 12, 32, 14, 26, 34, 10, 8, 28, 38, 20} 构建成 2-3 树，并保证数据插入的大小顺序。(演示一下构建 2-3 树的过程.)
在这里插入图片描述

  1. 插入规则:
    （1）2-3 树的所有叶子节点都在同一层.(只要是 B 树都满足这个条件)
    （2）有两个子节点的节点叫二节点，二节点要么没有子节点，要么有两个子节点.
    （3）有三个子节点的节点叫三节点，三节点要么没有子节点，要么有三个子节点
    （4）当按照规则插入一个数到某个节点时，不能满足上面三个要求，就需要拆，先向上拆，如果上层满，则拆本层，拆后仍然需要满足上面 3 个条件。
    （5）对于三节点的子树的值大小仍然遵守(BST 二叉排序树)的规则

12.2.3 其他说明

除了 23 树，还有 234 树等，概念和 23 树类似，也是一种B 树。 如图:
在这里插入图片描述

12.3 B 树、B+树和 B*树

12.3.1 B树的介绍

  1. 前面介绍的 2-3 树和 2-3-4 树，他们就是B 树(英语：B-tree 也写成 B-树)，
    这里我们再做一个说明，我们在学 习 Mysql 时，经常听到说某种类型的索引是基于 B 树或者 B+树的，如图:
    在这里插入图片描述
  2. 对上图的说明:
    （1） B 树的阶：节点的最多子节点个数。比如 2-3 树的阶是3，2-3-4 树的阶是 4
    （2）B-树的搜索，从根结点开始，对结点内的关键字（有序）序列进行二分查找，如果命中则结束，否则进入查询关键字所属范围的儿子结点；重复，直到所对应的儿子指针为空，或已经是叶子结点
    （3）关键字集合分布在整颗树中, 即叶子节点和非叶子节点都存放数据.
    （4） 搜索有可能在非叶子结点结束
    （5）其搜索性能等价于在关键字全集内做一次二分查找。

12.3.2 B+树

B+树是B 树的变体，也是一种多路搜索树。
在这里插入图片描述
对上图的说明:

  1. B+树的搜索与 B 树也基本相同，区别是 B+树只有达到叶子结点才命中（B 树可以在非叶子结点命中），其性能也等价于在关键字全集做一次二分查找
  2. 所有关键字都出现在叶子结点的链表中（即数据只能在叶子节点【也叫稠密索引】），且链表中的关键字(数据)恰好是有序的。
  3. 不可能在非叶子结点命中
  4. 非叶子结点相当于是叶子结点的索引（稀疏索引），叶子结点相当于是存储（关键字）数据的数据层
  5. 更适合文件索引系统
  6. B 树和 B+树各有自己的应用场景，不能说 B+树完全比B 树好，反之亦然.

12.3.4 B*树

B树是 B+树的变体，在 B+树的非根和非叶子结点再增加指向兄弟的指针。
在这里插入图片描述
B树的说明:

  1. B* 树定义了非叶子结点关键字个数至少为(2/3)*M(M：度)，即块的最低使用率为 2/3，而 B+树的块的最低使用率为的1/2。
  2. 从第 1 个特点我们可以看出，B*树分配新结点的概率比 B+树要低，空间使用率更高

第13章 图

13.1 图的基本介绍

13.1.1 为什么要用图

  1. 前面我们学了线性表和树
  2. 线性表局限于一个直接前驱和一个直接后继的关系
  3. 树也只能有一个直接前驱也就是父节点
  4. 当我们需要表示多对多的关系时， 这里我们就用到了图。

13.1.2 图的常用概念

  1. 顶点(vertex)
  2. 边(edge)
  3. 路径
  4. 无向图(右图
  5. 有向图
  6. 带权图
    在这里插入图片描述

13.2 图的表示方式

图的表示方式有两种：二维数组表示（邻接矩阵）；链表表示（邻接表）。

13.2.1 邻接矩阵

邻接矩阵是表示图形中顶点之间相邻关系的矩阵，对于 n 个顶点的图而言，矩阵是的row 和col 表示的是1…n个点。
在这里插入图片描述

13.2.2 邻接表

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

13.3 图的快速入门案例

  1. 要求: 代码实现如下图结构.
    在这里插入图片描述
  2. 思路分析 (1) 存储顶点 String 使用 ArrayList (2) 保存矩阵 int[][] edges
package com.atguigu.graph;
import java.util.ArrayList;
import java.util.Arrays;
public class Graph {
	private ArrayList<String> vertexList;	//存储顶点集合
	private int[][] edges;					//存储图的邻接矩阵
	private int numOfEdges;					//表示边的数目
	public static void main(String[] args) {
		//测试一把
		int n = 5;
		String Vertexs[]={"A","B","C","D","E"};
		//创建图对象
		Graph graph = new Graph(n);
		//循环添加顶点
		for (String vertex : Vertexs) {
			graph.insertVertex(vertex);
		}
		//添加边:A-B,A-C,B-C,B-D,B-E
		graph.insertEdge(0, 1, 1);	//A-B
		graph.insertEdge(0, 2, 1);	//A-B
		graph.insertEdge(1, 2, 1);	//A-B
		graph.insertEdge(1, 3, 1);	//A-B
		graph.insertEdge(1, 4, 1);	//A-B
		
		//显示邻接矩阵
		graph.showGraph();
		
	}
	
	//构造器
	public Graph(int n) {
		//初始化矩阵和vertexList
		edges = new int[n][n];
		vertexList = new ArrayList<String>();
		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 getNumOfVertex() {
		return vertexList.size();
	}
	
	//得到边的数目
	public int getNumOfEdges() {
		return numOfEdges;
	}
	
	//返回节点i(下标）对应的数据：0->A，1->B，2->C
	public String getValueByIndex(int i) {
		return vertexList.get(i);
	}
	//返回V1和v2的权值
	public int getWeight(int v1, int v2) {
		return edges[v1][v2];
	}
	
	//显示图对应的矩阵
	public void showGraph() {
		for (int[] link	: edges) {
			System.out.println(Arrays.toString(link));
		}
	}
}

3.4 图的深度优先遍历介绍

13.4.1 图遍历介绍

所谓图的遍历，即是对结点的访问。一个图有那么多个结点，如何遍历这些结点，需要特定策略，一般有两种 访问策略: (1)深度优先遍历 (2)广度优先遍历

13.4.2 深度优先遍历基本思想

图的深度优先搜索(Depth First Search) 。

  1. 深度优先遍历，从初始访问结点出发，初始访问结点可能有多个邻接结点，深度优先遍历的策略就是首先访问第一个邻接结点，然后再以这个被访问的邻接结点作为初始结点，访问它的第一个邻接结点， 可以这样理解： 每次都在访问完当前结点后首先访问当前结点的第一个邻接结点。
  2. 我们可以看到，这样的访问策略是优先往纵向挖掘深入，而不是对一个结点的所有邻接结点进行横向访问。
  3. 显然，深度优先搜索是一个递归的过程

13.4.3 深度优先遍历算法步骤

  1. 访问初始结点 v，并标记结点 v 为已访问。
  2. 查找结点 v 的第一个邻接结点 w。
  3. 若 w 存在，则继续执行 4，如果w 不存在，则回到第1 步，将从v 的下一个结点继续。
  4. 若 w 未被访问，对 w 进行深度优先遍历递归（即把w 当做另一个 v，然后进行步骤123）。 5) 查找结点 v 的 w 邻接结点的下一个邻接结点，转到步骤 3。

13.4.4 深度优先算法的代码实现

在这里插入图片描述
关键代码


/**
 * 返回某个节点的第一个邻接节点
 * @param index:要查找的节点的下标
 * @return:index的第一个邻接节点的下标。
 */
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：与V1相连的，v2之后的节点
 * @return：返回v2后的节点的下标。
 */
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;
}

/**
 * 深度优先算法
 * @param isVisited：各节点是否被访问的状态列表
 * @param i：初始节点
 */
private void dfs(boolean[] isVisited, int i) {
	//首先将第一个节点输出
	System.out.print(getValueByIndex(i)+"->");
	//将节点设置为已经被访问
	isVisited[i] = true;
	//查找节点i的第一个邻接节点w
	int w = getFirstNeighbor(i);
	while (w != -1) {
		if (!isVisited[w]) {
			dfs(isVisited, w);
		}
		//如果w节点已经被访问过
		w = getNextNeighbor(i, w);
	}
}

//对dfs进行重载，遍历所有的节点，并进行dfs
public void dfs() {
	//遍历所有节点，进行dfs[回溯]
	for (int i = 0; i < getNumOfVertex(); i++) {
		if (!isVisited[i]) {
			dfs(isVisited, i);
		}
	}
}

13.5 图的广度优先遍历

13.5.1 广度优先遍历基本思想

类似于一个分层搜索的过程，广度优先遍历需要使用一个队列以保持访问过的结点的顺序，以便按这个顺序来访问这些结点的邻接结点

13.5.2 广度优先遍历算法步骤

  1. 访问初始结点 v 并标记结点 v 为已访问。
  2. 结点 v 入队列
  3. 当队列非空时，继续执行，否则算法结束。
  4. 出队列，取得队头结点 u。
  5. 查找结点 u 的第一个邻接结点 w。
  6. 若结点 u 的邻接结点 w 不存在，则转到步骤 3；否则循环执行以下三个步骤：
    6.1 若结点 w 尚未被访问，则访问结点 w 并标记为已访问。
    6.2 结点 w 入队列
    6.3 查找结点 u 的继 w 邻接结点后的下一个邻接结点 w，转到步骤6。

关键代码

//广度优先算法
private void bfs(boolean[] isVisited, int i) {
	int u ;		//表示队列的头结点对应的下标
	int w ;		//邻接节点w
	LinkedList<Object> queue = new LinkedList<>();	//队列，记录节点访问的顺序
	System.out.print(getValueByIndex(i)+"->");
	isVisited[i] = true ;		//标记为已访问
	queue.addLast(i); 			//将节点加入队列
	while ( !queue.isEmpty()) {
		//取出队列的头结点下标
		u = (Integer)queue.removeFirst();
		//得到第一个邻接节点的下标w
		w = getFirstNeighbor(u);
		while (w != -1) {		//找到
			//是否被访问过
			if (!isVisited[w]) {
				System.out.print(getValueByIndex(w)+"->");
				//标记已经访问
				isVisited[w] = true;
				//入队
				queue.addLast(w);
			}
			//以u为前驱点，找w后面的下一个节点
			w = getNextNeighbor(u, w);		//体现广度优先搜索
		}
	}
}

//重载遍历所有节点，都进行广度优先算法
public void bfs() {
	for (int i = 0; i < getNumOfVertex(); i++) {
		if (! isVisited[i]) {
			bfs(isVisited, i);
		}
	}
}

代码汇总

package com.atguigu.graph;

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) {
		//测试一把
		int n = 5;
		String Vertexs[]={"A","B","C","D","E"};
		//创建图对象
		Graph graph = new Graph(n);
		//循环添加顶点
		for (String vertex : Vertexs) {
			graph.insertVertex(vertex);
		}
		//添加边:A-B,A-C,B-C,B-D,B-E
		graph.insertEdge(0, 1, 1);	//A-B
		graph.insertEdge(0, 2, 1);	//A-B
		graph.insertEdge(1, 2, 1);	//A-B
		graph.insertEdge(1, 3, 1);	//A-B
		graph.insertEdge(1, 4, 1);	//A-B
		
		//显示邻接矩阵
		graph.showGraph();
		
		//深度遍历
		System.out.println("深度优先遍历");
		graph.bfs();
	}
	
	//构造器
	public Graph(int n) {
		//初始化矩阵和vertexList
		edges = new int[n][n];
		vertexList = new ArrayList<String>();
		numOfEdges = 0;
		isVisited = new boolean[5];
	}
	
	//插入节点
	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 getNumOfVertex() {
		return vertexList.size();
	}
	
	//得到边的数目
	public int getNumOfEdges() {
		return numOfEdges;
	}
	
	//返回节点i(下标）对应的数据：0->A，1->B，2->C
	public String getValueByIndex(int i) {
		return vertexList.get(i);
	}
	
	//返回V1和v2的权值
	public int getWeight(int v1, int v2) {
		return edges[v1][v2];
	}
	
	//显示图对应的矩阵
	public void showGraph() {
		for (int[] link	: edges) {
			System.out.println(Arrays.toString(link));
		}
	}

	/**
	 * 返回某个节点的第一个邻接节点
	 * @param index:要查找的节点的下标
	 * @return:index的第一个邻接节点的下标。
	 */
	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：与V1相连的，v2之后的节点
	 * @return：返回v2后的节点的下标。
	 */
	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;
	}
	
	/**
	 * 深度优先算法
	 * @param isVisited：各节点是否被访问的状态列表
	 * @param i：初始节点
	 */
	private void dfs(boolean[] isVisited, int i) {
		//首先将第一个节点输出
		System.out.print(getValueByIndex(i)+"->");
		//将节点设置为已经被访问
		isVisited[i] = true;
		//查找节点i的第一个邻接节点w
		int w = getFirstNeighbor(i);
		while (w != -1) {
			if (!isVisited[w]) {
				dfs(isVisited, w);
			}
			//如果w节点已经被访问过
			w = getNextNeighbor(i, w);
		}
	}
	
	//对dfs进行重载，遍历所有的节点，并进行dfs
	public void dfs() {
		//遍历所有节点，进行dfs[回溯]
		for (int i = 0; i < getNumOfVertex(); i++) {
			if (!isVisited[i]) {
				dfs(isVisited, i);
			}
		}
	}
	
	//广度优先算法
	private void bfs(boolean[] isVisited, int i) {
		int u ;		//表示队列的头结点对应的下标
		int w ;		//邻接节点w
		LinkedList<Object> queue = new LinkedList<>();	//队列，记录节点访问的顺序
		System.out.print(getValueByIndex(i)+"->");
		isVisited[i] = true ;		//标记为已访问
		queue.addLast(i); 			//将节点加入队列
		while ( !queue.isEmpty()) {
			//取出队列的头结点下标
			u = (Integer)queue.removeFirst();
			//得到第一个邻接节点的下标w
			w = getFirstNeighbor(u);
			while (w != -1) {		//找到
				//是否被访问过
				if (!isVisited[w]) {
					System.out.print(getValueByIndex(w)+"->");
					//标记已经访问
					isVisited[w] = true;
					//入队
					queue.addLast(w);
				}
				//以u为前驱点，找w后面的下一个节点
				w = getNextNeighbor(u, w);		//体现广度优先搜索
			}
		}
	}
	
	//重载遍历所有节点，都进行广度优先算法
	public void bfs() {
		for (int i = 0; i < getNumOfVertex(); i++) {
			if (! isVisited[i]) {
				bfs(isVisited, i);
			}
		}
	}
}
东风难破
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Java数据结构-树及树的存储结构
十六子
07-23 7705
树的定义：n（n>=0）个节点的有限集。 n=0时称为空树。 n!=0时为非空树，有且仅有一个特定的节点——根；n>1时，其它节点可以分为m（m>0）个互不相交的有限集T1~Tm，其中每一个集合本身又是一棵树，并且称为根的子树。 树的一些基本术语： 树的结点：由一个数据元素和若干个指向其子树的分支组成。 结点的度：结点所拥有的子树的个数（即分支数）称为该结点的度。 叶子结点：度为0的结点称为叶子结点
Java8新特性-使用Stream流递归实现遍历树形结构
weixin_39643007的博客
03-05 2982
1.实体类： package entity; import lombok.Builder; import lombok.Data; import java.util.List; /** * 描述:Menu * * @author 何志鹏 * @ClassName:Menu * @create 2021-03-05 10:42 * Version 1.0 */ @Data @Builder public class Menu { /** * id */.
Java算法12—树结构之2-3-4树
fujiedada的专栏
03-05 313
通过前面的介绍，我们知道在二叉树中，每个节点只有一个数据项，最多有两个子节点。如果允许每个节点可以有更多的数据项和更多的子节点，就是多叉树。本篇博客我们将介绍的——2-3-4树，它是一种多叉树，它的每个节点最多有四个子节点和三个数据项。 1 2-3-4 树介绍 2-3-4树每个节点最多有四个字节点和三个数据项，名字中 2,3,4 的数字含义是指一个节点可能含有的子节点的个数。对于非叶节点有三种可能...
深入理解java的数据结构之树详解篇一（二叉树的基础概念篇）
m0_46198325的博客
04-10 2549
java的数据结构与算法描述之队树 二叉树 二叉搜索树 平衡二叉树 红黑树
Java数据结构与算法 day11 多路查找树
杨丙寅
06-14 695
文章目录第11章 多路查找树二叉树与B树2-3树B树、B+树和B*树本章思维导图 第11章 多路查找树 二叉树与B树 二叉树的问题分析 二叉树的操作效率较高，但是也存在问题, 请看下面的二叉树： 二叉树需要加载到内存的，如果二叉树的节点少，没有什么问题，但是如果二叉树的节点很多(比如1亿)， 就存在如下问题: 问题1：在构建二叉树时，需要多次进行i/o操作(海量数据存在数据库或文件中)，节点海量，构建二叉树时，速度有影响. 问题2：节点海量，也会造成二叉树的高度很大，会降低操作速度.
数据结构与算法.xmind
06-19
数据结构与算法 排序算法 内排序 八大基础排序 选择排序 简单选择排序 思想 每次选择最大的数插入到末尾中 做法 外层for循环控制次数 内层for循环找出最大的值的角...
ApacheCN 数据结构与算法译文集.zip
最新发布
06-16
**ApacheCN 数据结构与算法译文集.zip** 是一个包含了多语言版本的数据结构与算法学习资源的压缩包，特别适合正在学习或准备学习C/C++/JAVA/Python编程语言的大学生。这个资源集旨在帮助他们深入理解数据结构和算法...
数据结构与算法——专栏索引篇
01-20
我在我的博客中，会用C语言讲解数据结构与算法中的重要知识点，不仅是因为C语言是基础，更是因为C语言的多变性，而且C语言是较为复杂的，我们需要自己手动去实现很多东西，不像Python,Java,很多东西已经在那里了，...
【超全！】图解Java数据结构和算法(共195集)【资料+视频+课件+代码+笔记】
10-13
稀疏数组、单向队列、环形队列、单向链表、双向链表、环形链表、约瑟夫问题、栈、前缀、中缀、后缀表达式、中缀表达式转换为后缀表达式、递归与回溯、迷宫问题、八皇后问题、算法的时间复杂度、冒泡排序、选择排序、...
Java实现多叉树查找
12-22
1 package tree; 　　2 　　3 import java.util.List; 　　4 import java.util.ArrayList; 　　5 import java.io.Serializable; 　　6 　　7 public class TreeNode implements Serializable { 　　8     private int parentId; 　　9     private int selfId; 　　10     protected String nodeName; 　　11     protected Object ob
重温数据结构：树 及 Java 实现
热门推荐
张拭心的博客 shixinzhang
11-17 3万+
读完本文你将了解到： 什么是树 树的相关术语 根节点、父亲节点、孩子节点、叶子节点如上所述。 节点的度 树的度 节点的层次 树的高度 树的深度 树的两种实现 数组表示： 链表表示的节点： 树的几种常见分类及使用场景 数据结构，指的是数据的存储形式，常见的有线性结构（数组、链表，队列、栈），还有非线性结构（树、图等）。 今天我们来学习下数据结构中的 树。 什么是...
Java实现树形图
weixin_44548741的博客
08-06 3817
实现树形图最主要的就是用到键值对，而java中可以实现键值对的可以用map集合来实现键值对，但是map并不是集合，它只是集合的分类但不是集合。 树形图实现效果 数据库设计 通过键值对来查询数据 封装好类 public class area { private int AreaID; private String AreaName; private int AreaCityID; public ...
java递归查找树是否存在某个节点
sinho_2014的博客
06-25 1327
忘了在哪里看到的题目了，有这样一种树形结构（如下图），用递归的方法查找是否存在某个节点。网上找了很久，都是遍历子节点的，都不是我想要的答案，于是自己手动写了，想知道各位大佬还有没有其他方法。上...
java实现树_数据结构与算法
Aye
04-04 1091
1.二叉树：n个具有相同类型的数据元素的有限集合；左子树-根-右子树；有序。2.二叉树的度：最大的节点度数3.满二叉树：所有分支节点均存在左子树和右子树，且所有叶子节点均在同一层上4.完全二叉树：存在的节点与满二叉树的节点编号相同，叶子节点只存在最后一层及倒数第二层5.非空二叉树的i层最多有 2【i-1】个节点6.深度为k的二叉树至多有2【k】-1个节点7.给出完全二叉树的节点数则完全二叉树的深度...
LeetCode 124 二叉树中的最大路径和（困难）
嗷嗷嗷嗷的博客
11-08 116
给定一个非空二叉树，返回其最大路径和。 本题中，路径被定义为一条从树中任意节点出发，沿父节点-子节点连接，达到任意节点的序列。该路径至少包含一个节点，且不一定经过根节点。 示例 1： 输入：[1,2,3] 1 / \ 2 3 输出：6 示例 2： 输入：[-10,9,20,null,null,15,7] -10 / \ 9 20 / \ 15 7 输出：42 思路与代码 递归法 class Solution { i
自己写的java实现的多路搜索树 B-Tree
Wang100gui的专栏
01-20 831
最近需要写范围查询的功能，最简单的应该是B+树吧，在了解B+树的时候，也看到了B-树。于是想先实现B-Tree再实现B+Tree，结果网上并没有找到B-Tree（多路搜索树），于是自己用java实现了一个，经过自己设计了很多测试用例，用Junit（临时学的）测试可用。在这里贴出来，希望能给初学者一点参考，也希望能有高人指点可以改进的地方，欢迎讨论批评指点！自己之前一直在做工程，这是一年多来首次写数据结构，自己还很弱，欢迎大家批评指正！！！
树形结构递归遍历，根据某个属性值查找其所在的对象
摆脱菜鸟，砥砺前行
11-07 1万+
今天在做一个组织结构图时，图是用一个树来表示的，有唯一的根节点以及若干个子节点，二话不说我瞬间就写出来了这个结构，我的定义如下： var data = { id: 1, name: "根节点", children:[{ id: 2, name: "节点1", children: [{ i...
数据结构与算法 全 数据结构与算法全 Java
03-04
"数据结构与算法的全面讲解，主要针对Java语言进行阐述，涵盖了算法的基础概念、数据结构的种类以及相关的编程练习。" 在计算机科学中，数据结构与算法是两个核心概念。数据结构指的是组织和存储数据的方式，而算...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

东风难破

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值