java树形递归
使用Java将一个List运用递归转成树形结构案例
使⽤Java将⼀个List运⽤递归转成树形结构案例在开发中，我们会遇到将不同组织架构合并成tree这种树状结构，那么如果做呢？实际上，我们也可以理解为如何将拥有⽗⼦关系的list转成树形结构，⽽这其中主要的⽅法就是递归！1、实体对象：@Datapublic class Node {private Integer id;private String city;private Integer pid;private List<Node> children;public Node(Integer id,String city,Integer pid){this.id = id;this.city = city;this.pid = pid;}}2、转换⼯具类：public class TreeUtils {//把⼀个List转成树static List<Node> buildTree(List<Node> list,Integer pid){List<Node> tree=new ArrayList<>();for(Node node:list){if(Objects.equals(node.getPid(),pid)){tree.add(findChild(node,list));}}return tree;}static Node findChild(Node node, List<Node> list){for(Node n:list){if(Objects.equals(n.getPid(),node.getId())){if(node.getChildren() == null){node.setChildren(new ArrayList<Node>());}node.getChildren().add(findChild(n,list));}}return node;}public static void main(String[] args) {Node node0=new Node(0,"中国",-1);Node node1=new Node(1,"湖北省",0);Node node2=new Node(2,"武汉市",1);Node node3=new Node(3,"洪⼭区",2);Node node4=new Node(4,"宜昌市",1);Node node5=new Node(5,"上海市",0);Node node6=new Node(6,"静安区",5);List<Node> list=new ArrayList<>();list.add(node3);list.add(node4);list.add(node1);list.add(node2);list.add(node5);list.add(node6);list.add(node0);List<Node> nodes = buildTree(list,-1);System.out.println(JSON.toJSONString(nodes));}}3、运⾏结果：这样list就成功转换成为了tree装结构到此这篇关于使⽤Java将⼀个List运⽤递归转成树形结构案例的⽂章就介绍到这了,更多相关Java将list运⽤成树形结构内容请搜索以前的⽂章或继续浏览下⾯的相关⽂章希望⼤家以后多多⽀持！。
java循环和递归
java循环和递归在Java编程中，循环和递归是两种常用的控制结构，用于解决重复性的任务和处理递归问题。
循环可以用来重复执行一段代码，而递归则是通过调用自身来解决问题。
本文将介绍Java中的循环和递归的概念、用法和一些常见的应用场景。
一、循环的概念和用法循环是一种重复执行一段代码的控制结构。
在Java中，常见的循环结构有for循环、while循环和do-while循环。
1. for循环for循环是一种在已知循环次数的情况下重复执行一段代码的结构。
它的语法如下：```for (初始化表达式; 循环条件; 更新表达式) {// 循环体}```其中，初始化表达式用于初始化循环变量；循环条件是一个布尔表达式，用于判断是否继续执行循环；更新表达式用于更新循环变量的值。
for循环的执行顺序是先执行初始化表达式，然后判断循环条件，如果为真则执行循环体，然后执行更新表达式，再次判断循环条件，以此类推，直到循环条件为假时结束循环。
for循环的一个常见应用是遍历数组或集合。
例如，可以使用for循环计算数组中元素的总和：```int[] nums = {1, 2, 3, 4, 5};int sum = 0;for (int i = 0; i < nums.length; i++) {sum += nums[i];}System.out.println("数组的总和为：" + sum);```2. while循环while循环是一种在未知循环次数的情况下重复执行一段代码的结构。
它的语法如下：```while (循环条件) {// 循环体}```while循环的执行顺序是先判断循环条件，如果为真则执行循环体，然后再次判断循环条件，以此类推，直到循环条件为假时结束循环。
while循环的一个常见应用是读取用户输入，直到满足特定条件为止。
例如，可以使用while循环验证用户输入的密码是否正确：```import java.util.Scanner;Scanner scanner = new Scanner(System.in);String password = "123456";String input;do {System.out.println("请输入密码：");input = scanner.nextLine();} while (!input.equals(password));System.out.println("密码正确！");```3. do-while循环do-while循环是一种在未知循环次数的情况下重复执行一段代码的结构，与while循环的区别在于它先执行一次循环体，然后再判断循环条件。
java解析四则运算为树形的方法_概述及解释说明
java解析四则运算为树形的方法概述及解释说明1. 引言1.1 概述：本文将讨论Java解析四则运算为树形结构的方法。
四则运算是数学中最基础的运算，包括加法、减法、乘法和除法。
通过对四则运算表达式进行解析，可以将其转化为树形结构，以提供更方便的处理和计算方式。
在本文中，我们将介绍四则运算及其解析方式的简介，并重点关注树形结构在这种解析中的应用。
1.2 文章结构：本文共分为5个部分：引言、正文、解释说明、结论和后记。
在引言部分，我们将给出文章的概述，简述整篇文章的内容与目标。
在正文部分，我们将详细介绍四则运算及其解析方式的简介，并探究树形结构在这种解析中的作用。
在解释说明部分，我们会阐述将四则运算表达式转化为树形结构的基本概念和原理，并讨论Java中实现这一过程的方法。
接着，我们还会探讨树形结构在四则运算解析中的优势和应用场景。
在结论部分，我们将总结文章要点和重点论述内容，并对Java解析四则运算为树形的方法进行评价并展望未来的发展方向。
最后，在后记部分，我们将留下一些附加信息和感想。
1.3 目的：本文的目的是提供一个全面且易懂的解析四则运算为树形结构的方法，并探讨这种方法在Java中的应用。
通过深入了解四则运算的解析和树形结构的应用，读者可以更好地理解并使用这些技术，进一步提高程序设计和算法实现能力。
本文还旨在为Java开发者提供一个可靠而有效的工具，以便于他们处理复杂的四则运算表达式。
跟随本文学习并实践这种方法可以增强编码技巧和培养抽象思维能力，在日常开发中收获不少益处。
2. 正文:2.1 四则运算及其解析方式简介:在数学中，四则运算指的是加法、减法、乘法和除法这四种基本运算。
它们是最常见和基础的数学运算，广泛应用于各个领域。
在计算机科学中，我们通常需要将四则运算表达式进行解析，以便计算机能够理解和执行。
2.2 树形结构在四则运算解析中的应用:树形结构是一种非常适合表示嵌套层次关系的数据结构。
部门树形结构算法—Java递归实现
部门树形结构算法—Java递归实现将查询到的部门列表数据，进⾏⽗⼦节点树形结构排序该功能适⽤需要树形结构的，不仅仅是部门树步骤：1. 查询数据库，获得所有的部门列表2. 调⽤下⾯的实现⽅法⼀、建表语句CREATE TABLE `dept` (`deptId` bigint(20) NOT NULL AUTO_INCREMENT COMMENT '主键',`name` varchar(32) DEFAULT NULL COMMENT '部门名称',`parentId` bigint(20) DEFAULT NULL COMMENT '⽗级部门ID',PRIMARY KEY (`deptId`)) ENGINE=InnoDB DEFAULT CHARSET=utf8⼆、Java实体类package com.changge.pojo;import java.util.ArrayList;import java.util.List;/*** 部门实体** @author 长歌*/public class Dept {/*** 部门id*/private String deptId;/*** 部门名称*/private String name;/*** ⽗部门id*/private String parentId;/*** ⼦部门*/private List<Dept> children = new ArrayList<>();// get,set等⽅法省略...三、实现⽅法代码/*** 构建前端所需要树结构** @param depts 部门列表* @return 树结构列表*/public List<Dept> buildDeptTree(List<Dept> depts) {List<Dept> deptList = new ArrayList<>();List<String> deptIdList = new ArrayList<>();for (Dept dept : depts) {deptIdList.add(dept.getDeptId());}for (Dept dept : depts) {// 如果是顶级节点，遍历该⽗节点所有⼦节点if (!deptIdList.contains(dept.getParentId())) {recursionFn(depts, dept);deptList.add(dept);}}if (deptList.isEmpty()) {deptList = depts;}return deptList;}/*** 递归列表* 结束条件为所遍历的节点⽆下⼀级节点** @param list 查询获得的所有部门数据* @param dept 顶级节点*/private void recursionFn(List<Dept> list, Dept dept) {// 得到⼦节点列表List<Dept> childList = getChildList(list, dept);dept.setChildren(childList);for (Dept tChild : childList) {// 如果⼦节点有下⼀级节点，得到下⼀级的节点列表if (hasChild(list, tChild)) {recursionFn(list, tChild);}}}/*** 获得该节点的下⼀级⼦节点列表** @param list 查询获得的所有部门数据* @param dept 顶级节点* @return 顶级节点的下⼀级⼦节点列表*/private List<Dept> getChildList(List<Dept> list, Dept dept) {List<Dept> deptList = new ArrayList<>();for(Dept d:list){// 遍历⾮顶级节点，并获得传⼊参数顶级节点的下⼀级⼦节点列表if (d.getParentId() != null && d.getParentId().equals(dept.getDeptId())) { deptList.add(d);}}return deptList;}/*** 判断是否有⼦节点** @param list 节点列表* @param dept 部门节点* @return Boolean*/private boolean hasChild(List<Dept> list, Dept dept) {return getChildList(list, dept).size() > 0;}。
JAVA递归生成树形菜单
JAVA递归⽣成树形菜单 递归⽣成⼀个如图的菜单，编写两个类数据模型Menu、和创建树形的MenuTree。
通过以下过程实现： 1.⾸先从菜单数据中获取所有根节点。
2.为根节点建⽴次级⼦树并拼接上。
3.递归为⼦节点建⽴次级⼦树并接上，直⾄为末端节点拼接上空的“树”。
⾸先，编写数据模型Menu。
每条菜单有⾃⼰的id、⽗节点parentId、菜单名称text、菜单还拥有次级菜单children。
1import java.util.List;23public class Menu {4private String id;5private String parentId;6private String text;7private String url;8private String yxbz;9private List<Menu> children;10public Menu(String id,String parentId,String text,String url,String yxbz) {11this.id=id;12this.parentId=parentId;13this.text=text;14this.url=url;15this.yxbz=yxbz;16 }17/*省略get\set*/18 } 创建树形结构的类MenuTree。
⽅法getRootNode获取所有根节点，⽅法builTree将根节点汇总创建树形结构，buildChilTree为节点建⽴次级树并拼接上当前树，递归调⽤buildChilTree不断为当前树开枝散叶直⾄找不到新的⼦树。
完成递归，获取树形结构。
1import java.util.ArrayList;2import java.util.List;34public class MenuTree {5private List<Menu> menuList = new ArrayList<Menu>();6public MenuTree(List<Menu> menuList) {7this.menuList=menuList;8 }910//建⽴树形结构11public List<Menu> builTree(){12 List<Menu> treeMenus =new ArrayList<Menu>();13for(Menu menuNode : getRootNode()) {14 menuNode=buildChilTree(menuNode);15 treeMenus.add(menuNode);16 }17return treeMenus;18 }1920//递归，建⽴⼦树形结构21private Menu buildChilTree(Menu pNode){22 List<Menu> chilMenus =new ArrayList<Menu>();23for(Menu menuNode : menuList) {24if(menuNode.getParentId().equals(pNode.getId())) {25 chilMenus.add(buildChilTree(menuNode));26 }27 }28 pNode.setChildren(chilMenus);29return pNode;30 }3132//获取根节点33private List<Menu> getRootNode() {34 List<Menu> rootMenuLists =new ArrayList<Menu>();35for(Menu menuNode : menuList) {36if(menuNode.getParentId().equals("0")) {37 rootMenuLists.add(menuNode);38 }39 }40return rootMenuLists;41 }42 } 最后，插⼊⼀些数据试试效果。
java 树形结构递归过滤
java 树形结构递归过滤Java树形结构递归过滤在Java编程中，树形结构是一种非常常见的数据结构。
它由一系列的节点构成，这些节点按照一定的层次关系连接起来。
树形结构可以用于模拟现实中的各种场景，比如文件系统、组织结构等。
然而，在实际应用中，我们经常需要对树形结构进行一些操作，如搜索、过滤等。
本文将重点讨论如何使用递归来对树形结构进行过滤操作。
第一步：了解树形结构在开始之前，首先要了解树形结构的基本概念。
树形结构由一个根节点和若干个子节点组成，每个节点包含数据以及连接到下一层节点的指针。
节点之间的连接关系遵循一定的层次关系，即每个节点最多有一个父节点和多个子节点。
# 示例：文件系统我们以文件系统为例来说明树形结构的概念。
在文件系统中，根节点表示整个文件系统，它的子节点表示根目录下的所有文件和文件夹。
每个子节点又可以有自己的子节点，构成了一个递归的树形结构。
例如，我们可以构建如下的文件系统树形结构：C:\Program FilesJavajdkbinlibApacheTomcatconflibUsersAliceBob在这个示例中，根节点表示C盘，它有两个子节点Program Files和Users。
以此类推，我们可以进一步展开每个子节点，直到最底层的叶子节点。
第二步：树形结构的递归过滤接下来，我们将树形结构的递归过滤问题进行具体讨论。
假设我们有一个文件系统树形结构，我们想要找出其中所有包含某个关键词的文件或文件夹。
这时，递归过滤就能帮助我们实现这个目标。
# 实现思路首先，我们需要定义一个递归函数来实现树形结构的遍历和过滤操作。
这个函数的输入参数包括当前节点、过滤关键词以及存储结果的数据结构。
函数的主要逻辑如下：1. 判断当前节点是否符合过滤条件，如果是，则将该节点添加到结果中。
2. 判断当前节点是否有子节点，如果有，则递归调用本函数继续遍历子节点。
3. 返回结果。
# 递归函数代码下面是一个简单的递归过滤函数的实现：javapublic void recursiveFilter(Node node, String keyword, List<Node>result) {if (node.getName().contains(keyword)) {result.add(node);}if (node.hasChildren()) {for (Node child : node.getChildren()) {recursiveFilter(child, keyword, result);}}}在这个代码中，我们通过判断节点的名称是否包含给定的关键词来决定是否将该节点添加到结果中。
java树形结构递归实现
java树形结构递归实现Java树形结构递归实现树（Tree）是一种常用的数据结构，在计算机技术中扮演着重要的角色。
树状数据结构由根节点，分支节点和叶子节点组成，以树状图准备表示。
树形结构由于具有高效查找，插入和删除的特点，被用于许多不同的数据结构和计算机程序设计。
本文将讨论在java语言中如何使用递归来实现树形结构。
一、为什么要使用递归1、简洁性：递归算法具有更高的理解度，使程序更加简洁；2、可扩展性：递归的特性使它更容易扩展和调整；3、清晰性：递归程序的清晰性以及可读性很高；4、减少代码行数：使用递归可以很好地避免冗余代码，减少代码行数；二、Java语言中树形结构的实现1、类定义：树形结构具有可重用性，因此我们可以创建一个tree类，用于描述树形结构；2、构造方法：构造一个完整的树结构，我们使用Tree constructor,该方法可以初始化树的属性.3、添加节点：为了添加一个新的节点到树，我们必须定义一个addNode方法。
4、获取节点：为了获取树节点的信息，我们定义了一个getNode方法.5、删除节点：为了删除一个树节点，我们定义了一个removeNode方法.6、重新构建：当需要将根节点重新构建为树节点时，我们定义了一个rebuildTree方法.三、递归实现1、使用递归遍历树的深度：当我们遍历树的深度时，我们需要用递归来遍历所有层次的节点，以及节点的子节点。
2、层序遍历：当我们要遍历树的层次时，也可以使用递归的方法。
先遍历第一层的节点，然后递归遍历每一层的子节点。
3、从叶子节点到根节点的遍历：当我们从叶子节点到根节点遍历时，可以采用递归的思想：先从叶子节点遍历，然后递归到节点的父节点，再递归到父节点的父节点，以此类推。
四、结论递归在java中可以有效地实现树形结构。
通过上面的介绍，可以看出，递归的特性使它在实现树形结构上性能优越，并且可以提高代码的可读性和可重用性，为树形结构的使用提供了更大的灵活性和更好的可扩展能力。
java list 树形数据排序方法
java list 树形数据排序方法Java中的List是一种常见的数据结构，它可以存储多个元素，并且可以动态地调整大小。
在实际的开发中，我们经常会遇到需要对树形数据进行排序的需求。
本文将介绍一些常用的方法和技巧，帮助我们对Java List中的树形数据进行排序。
一、树形数据结构简介树形数据结构是一种层次化的数据结构，它由节点和边组成。
每个节点可以有多个子节点，但只能有一个父节点，树形数据结构中的节点之间存在一种层次关系。
常见的树形数据结构有二叉树、多叉树和平衡树等。
二、List中树形数据的排序方法1. 自定义比较器在Java中，我们可以使用自定义比较器来对List中的树形数据进行排序。
比较器是一个实现了Comparator接口的类，它定义了比较两个对象的规则。
我们可以根据树形数据的特点，编写自定义比较器来实现排序。
例如，假设我们有一个树形数据的类TreeNode，它有一个属性value表示节点的值，还有一个属性children表示子节点列表。
我们可以编写一个自定义比较器TreeComparator来比较两个TreeNode对象的大小。
```javapublic class TreeComparator implements Comparator<TreeNode> {@Overridepublic int compare(TreeNode node1, TreeNode node2) {// 比较两个节点的值return node1.getValue().compareTo(node2.getValue());}}```然后，我们可以使用Collections.sort方法来对List中的树形数据进行排序。
```javaList<TreeNode> treeList = new ArrayList<>();// 添加树形数据到List中// ...// 使用自定义比较器进行排序Collections.sort(treeList, new TreeComparator());```2. 递归排序如果树形数据的结构比较复杂，或者我们需要按照多个属性进行排序，可以使用递归排序的方法。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
如何来做一棵递归树，这在前面的文章中有提过，但那是引用了myfaces组件的，今天就不用啥组件了，直接输出树的结构形状.数据库表数据一样，但还是在此重复一次。
我们的目标是：完成以下形态的树状.--管理---高级管理员----增加----删除----修改---普通管理员----增加一、建表/**--树形菜单节点编号节点名称节点链接址些节点父节点是否最底节点节点排序(一般用在同级节点上)节点说明*/drop table EPTreeTablecreate table EPTreeTable(TreeNodeId int identity(1,1) constraint pk_TreeNode primary key, TreeNodeName varchar(50) not null,TreeNodeLink varchar(100) ,TreeNodeFatherId int default 0, --0 为最高层TreeNodeIsBottom bit default 1, --1 为底层 0为非底层TreeNodeCompositor int default 1, -- 默认排在最后面TreeNodeExplain varchar(200))二、JAVA代码(1)TO对象/*** @author fangbiao* 用于映射父级菜单TO对象*/public class ParentResourcePojo {/*** 节点编号*/private int treeNodeId;/*** 节点名称*/private String treeNodeName;/*** 父节点*/private int treeParentNodeId;/*** @return treeNodeName*/public String getTreeNodeName() {return treeNodeName;}/*** @param treeNodeName 要设置的 treeNodeName*/public void setTreeNodeName(String treeNodeName) {this.treeNodeName = treeNodeName;}/*** @return treeParentNodeId*/public int getTreeParentNodeId() {return treeParentNodeId;}/*** @param treeParentNodeId 要设置的 treeParentNodeId*/public void setTreeParentNodeId(int treeParentNodeId) {this.treeParentNodeId = treeParentNodeId;}/*** @return treeNodeId*/public int getTreeNodeId() {return treeNodeId;}/*** @param treeNodeId 要设置的 treeNodeId*/public void setTreeNodeId(int treeNodeId) {this.treeNodeId = treeNodeId;}}（2）树形组合/*** 获取节点选择列表信息* @return*/public List getResourceList(){if(resourceList.size() == 0) {//获取高级的父节点resourceList = doTurnParentToTree(itbs.getTopParentResource()); }return resourceList;}private int num =2;private int tempTotalChildren ;private boolean temp = false;private int tempParent; //每次递归节点的父节点/*** 对父级列表进行树排* @param prp* @return*/private synchronized List doTurnParentToTree(ParentResourcePojo prp){ if(prp == null)return null;List list = getChildrenList(prp);//分线tempParent = prp.getTreeParentNodeId();String str = "";if(tempParent == 0){resourceList.add("-"+prp.getTreeNodeName()));}else{resourceList.add(prp.getTreeNodeName()));//每棵树的节点数目tempTotalChildren = list.size();}Iterator iterator = list.iterator();while(iterator.hasNext()){ParentResourcePojo treePojo = (ParentResourcePojo)iterator.next();if(tempParent != 0){if( tempParent < treePojo.getTreeParentNodeId()){if(temp == false)num += 1;}else if( tempParent > treePojo.getTreeParentNodeId()){num -=1;temp = false;}else if( tempParent == treePojo.getTreeParentNodeId() ){if(tempTotalChildren ==0)temp = false;elsetemp = true;}}for(int i=0;i<num;i++){str = str + "-";}treePojo.setTreeNodeName(CommonUtil.doAddAppendString(str,treePojo .getTreeNodeName()));str = "";doTurnParentToTree(treePojo);}return resourceList;}/*** 父级菜单列表*/private List allParentTreeList = null;/*** 做标记用*/private int flag = 0;/*** 获取所有父级菜单列表树* @return*/private List getAllParentTreeList(){if(allParentTreeList == null){if(flag == 0){flag = 1;allParentTreeList = itbs.getRRCResource();return allParentTreeList;}return allParentTreeList;}return allParentTreeList;}/*** 取子树列* @param prp* @return*/private List getChildrenList(ParentResourcePojo prp){List list = getAllParentTreeList();int listLength = list.size();List newReturnList = new ArrayList();if(listLength == 0)return newReturnList;List leaveList = new ArrayList();for(int i=0;i<listLength;i++){ParentResourcePojo prPojo = (ParentResourcePojo)list.get(i); int treePojoTreeParantNodeId = prPojo.getTreeParentNodeId(); int tpTreeNodeId = prp.getTreeNodeId();if(treePojoTreeParantNodeId == tpTreeNodeId){newReturnList.add(prPojo);}else{leaveList.add(prPojo);}}list = leaveList;return newReturnList;}到此完成，期间一定要注重同级节点的排序。