java 树结构递归

合集下载

java递归树型结构通用数据库

表结构/*** 删除部门删除时从选中级的所有子级** @param dept* @return*/public JsonResult delDept(Dept dept) {JsonResult jr = new JsonResult();Boolean flags=true;try {String str = "";User user=new User();List<Dept> sortList = new ArrayList<Dept>();sortList.add(dept);getDeptSortList(sortList,dept.getId()); //起始根节点id，等级为0for(Dept bean: sortList){user.setDeptId(bean.getId()); //判断部门下面是否有用户List<User> users =userDao.getByDeptIdIsUerOrNO(user);int userSize=users.size();if(userSize>0){jr.setMessage("部门名称：(" + users.get(0).getDeptName() + ")已有用户不能删除");flags=false;break;}}//部门没有被用户使用时才可以册子if(flags){for(Dept bean: sortList){dept.setId(bean.getId());deptDao.delDept(dept);jr.setMessage(SuccessMessageEnum.detele.toDescription());}}jr.setSuccess(true);} catch (Exception e) {log.error("DeptServiceImpl-->delDept:" + e.getMessage());jr.setCode(ExceptionEnum.SystemError.toCode());jr.setMessage(e.getMessage());}return jr;}/*** 删除时递归部门树** @param* @return*/public void getDeptSortList(List<Dept> sortDeptList,Integer parentId)throws Exception { Dept bean = null;//根据选中的部门id得到本部门和第一级所有的子部门的idList<Dept> deptslist=deptDao.getByDeptIdAllSubDeptId(parentId); //;//每次查询出上级为的分类// int deptSize=deptslist.size();if(deptslist.size() > 0){for(int i=0;i<deptslist.size();i++){bean = (Dept)deptslist.get(i);sortDeptList.add(bean);getDeptSortList(sortDeptList,bean.getId()); //递归查询}}}<select id="getByDeptIdAllSubDeptId" resultClass="Dept">select id from report_sys_dept where parent_id=#value#</select><delete id="delDept" parameterClass="Dept">delete from report_sys_dept where id = #id#;</delete>事例二表结构为：分类Id SortId所属分类Id ParentID分类名称SortName分类描述SortDesc测试数据：1000 0 A类A类1001 1000 A类_1 A类_11002 1000 A类_1 A类_11003 1001 A类_1_1 A类_1_12000 0 B类B类2001 2000 B类_1 B类_12002 2001 B类_1_1 B类_1_12003 1002 A类_1_1 A类_1_12004 2003 A类_1_1_1 A类_1_1_1java代码：（SortBean类略）/*** 查询分类的树型结构*/p ublic void getSortList(List<SortBean> sortList, Long parentId,int level){SortBean bean = null;List<SortBean> list = new ArrayList<SortBean>();String sql = "Select * from sort_ s where s.parentId = ?";try{System.out.println("sql:"+sql);list = (List<SortBean>)jdbcDao.queryBeanList(sql, SortBean.class, parentId);//每次查询出上级为的分类System.out.println(list.size());if(list != null && list.size() > 0){for(int i=0;i<list.size();i++){bean = (SortBean)list.get(i);bean.setLevel(level+1); //添加等级字段sortList.add(bean);getSortList(sortList,bean.getSortId(),level+1); //递归查询}}else{level--;}}catch(Exception e){e.printStackTrace();}}测试类：p ublic void test_getSortList() {SortService service = (SortService)beanFactory.getBean("sortService");List<SortBean> sortList = new ArrayList<SortBean>();service.getSortList(sortList, 0L, 0); //起始根节点id为0，等级为0for(SortBean bean: sortList){String str = "";for(int i=0;i<bean.getLevel();i++){str +="——";}System.out.println(str+bean.getSortId() + " " + bean.getParentId() + " " + bean.getSortName());}}查询结果：1000 0 A类|——1001 1000 A类_1|——1003 1001 A类_1_1|——1002 1000 A类_1|——2003 1002 A类_1_1|——2004 2003 A类_1_1_12000 0 B类|——2001 2000 B类_1|——2002 2001 B类_1_1。

java组织树递归详解

java组织树递归详解全文共四篇示例，供读者参考第一篇示例：Java组织树的递归是一种常见且重要的数据结构操作方法，通过递归算法可以方便地遍历和操作组织结构树。

在实际的项目开发中，经常会遇到需要处理组织结构树的情况，比如公司部门架构、树状菜单等。

本文将详细介绍Java组织树递归的原理、实现方式和应用场景。

一、理解组织树在开始讲述组织树的递归之前，首先需要理解什么是组织树。

组织树是一种树形结构，通常用来表示具有层级关系的数据。

比如一个公司的部门架构，可以用一个树形结构来表示，公司为根节点，各个部门为子节点，部门下还可能有子部门或者员工。

树形结构的特点是每个节点都可以有多个子节点，但只有一个父节点，形成了一种层级结构。

二、递归原理递归是一种编程技术，常用于解决问题时，将问题分解成相同类型的子问题，并对子问题进行求解，最终汇总结果。

在处理组织树时，递归的主要原理是通过递归方法，一层一层地对树的每个节点进行遍历，直到叶子节点为止。

递归方法通常需要递归调用自身，以实现对整个树形结构的遍历和操作。

三、组织树递归实现方式在Java中，可以通过递归方法来实现对组织树的遍历和操作。

下面我们以一个简单的示例来说明如何实现组织树的递归：假设有一个部门实体类Department，包含部门ID、部门名称、父部门ID等属性；```javapublic class Department {private Long id;private String name;private Long parentId;// 省略getter和setter方法}```接下来我们定义一个方法，通过递归方式遍历组织树：```javapublic void traverseDepartmentTree(Department department, List<Department> departmentList) {System.out.println(department.getName());List<Department> children = getChildren(department, departmentList);if(children != null && !children.isEmpty()) {for(Department child : children) {traverseDepartmentTree(child, departmentList);}}}private List<Department> getChildren(Department parent, List<Department> departmentList) {List<Department> children = new ArrayList<>();for(Department department : departmentList) {if(parent.getId().equals(department.getParentId())) {children.add(department);}}return children;}```在上面的示例中，traverseDepartmentTree方法接收一个部门对象和部门列表，首先输出当前部门的名称，然后调用getChildren方法获取当前部门的子部门列表，递归遍历子部门，直到叶子节点。

java组织树递归详解-概述说明以及解释

java组织树递归详解-概述说明以及解释1.引言概述部分的内容可以参考以下写法：1.1 概述在软件开发中，组织树递归是一种常见且重要的数据结构和算法，特别适用于涉及组织结构和层级关系的场景。

组织树递归可以帮助我们有效地组织和管理复杂的数据结构，用于表示组织机构、文件目录、分类层级等多种应用场景。

组织树递归的核心思想是通过递归调用，将复杂的问题分解为相对简单的子问题来解决。

通过定义一个递归函数，在函数内部不断调用自身，不断地将问题规模缩小，直到达到终止条件。

这种分而治之的思想可以大大简化问题的解决过程，并且能够很好地利用计算机的存储和运算能力。

本文将详细介绍组织树递归的概念、原理和在Java语言中的实现方式。

首先，我们将对什么是组织树进行解释，介绍递归的基本概念和特点。

然后，我们将着重讨论在Java语言中如何使用递归来实现组织树。

通过具体的代码示例和实践案例，我们将带领读者深入了解组织树递归的优势和使用注意事项。

通过阅读本文，读者将能够全面了解组织树递归在软件开发中的重要性和应用场景，并且能够灵活运用Java语言的递归特性来解决实际问题。

无论是初学者还是有一定经验的开发者，都能够从本文中收获实用而深入的知识，提升自己的编程能力。

接下来，让我们开始深入探索组织树递归吧！1.2 文章结构本篇文章主要围绕Java组织树递归展开讨论，旨在详细介绍组织树的概念和递归的工作原理，并给出Java中实现递归的方法和技巧。

文章结构安排如下：引言部分概述了文章的主题和目的，为读者提供了对整篇文章的总体认识。

概述部分简要介绍了组织树与递归的关系，并提供了本文的整体结构安排。

正文部分是本文的核心内容，分为三个小节。

2.1小节首先解释了什么是组织树，包括组织树的定义和组织树的应用场景。

2.2小节详细介绍了递归的概念，包括递归的定义、递归的基本原理和递归的优缺点。

2.3小节重点讲解了如何在Java中实现递归，包括递归函数的编写和递归的调用方式。

部门树形结构算法—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 递归树结构通用方法摘要：1.递归树结构概述2.递归树结构的实现方法3.递归树结构的应用场景4.总结正文：递归树结构是一种在计算机科学中广泛应用的数据结构，它的特点是节点之间存在递归关系。

递归树结构在很多算法和程序设计中都有体现，比如二叉搜索树、决策树等。

本文将介绍递归树结构的通用方法，并举例说明其在实际应用中的作用。

一、递归树结构概述递归树是一种特殊的树结构，它的每个节点都有两个子节点，这两个子节点之间存在递归关系。

在实际应用中，递归树可以用来表示具有层次关系的数据，如文件系统、数据压缩等。

递归树结构的特点如下：1.每个节点最多有两个子节点；2.节点之间的连接是有向的；3.根节点没有父节点，叶子节点没有子节点；4.节点之间的距离是递增的。

二、递归树结构的实现方法在Java中，可以通过定义一个类来表示递归树节点，并实现相应的递归方法。

以下是一个简单的递归树结构实现示例：```javaclass RecursiveTreeNode {int value;RecursiveTreeNode left;RecursiveTreeNode right;public RecursiveTreeNode(int value) {this.value = value;this.left = null;this.right = null;}public void display() {if (this.left != null) {this.left.display();}System.out.println(this.value);if (this.right != null) {this.right.display();}}public static void main(String[] args) {RecursiveTreeNode root = new RecursiveTreeNode(1);root.left = new RecursiveTreeNode(2);root.right = new RecursiveTreeNode(3);root.left.left = new RecursiveTreeNode(4);root.left.right = new RecursiveTreeNode(5);root.right.left = new RecursiveTreeNode(6);root.right.right = new RecursiveTreeNode(7);root.display();}}```上述代码定义了一个简单的递归树，并实现了display()方法用于展示树的结构。

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树形结构1、准备表结构及对应的表数据a、表结构：create table TB_TREE(CID NUMBER not null,CNAME VARCHAR2(50),PID NUMBER //⽗节点)b、表数据：insert into tb_tree (CID, CNAME, PID) values (1, '中国', 0);insert into tb_tree (CID, CNAME, PID) values (2, '北京市', 1);insert into tb_tree (CID, CNAME, PID) values (3, '⼴东省', 1);insert into tb_tree (CID, CNAME, PID) values (4, '上海市', 1);insert into tb_tree (CID, CNAME, PID) values (5, '⼴州市', 3);insert into tb_tree (CID, CNAME, PID) values (6, '深圳市', 3);insert into tb_tree (CID, CNAME, PID) values (7, '海珠区', 5);insert into tb_tree (CID, CNAME, PID) values (8, '天河区', 5);insert into tb_tree (CID, CNAME, PID) values (9, '福⽥区', 6);insert into tb_tree (CID, CNAME, PID) values (10, '南⼭区', 6);insert into tb_tree (CID, CNAME, PID) values (11, '密云县', 2);insert into tb_tree (CID, CNAME, PID) values (12, '浦东', 4);2、TreeNode对象，对应tb_treepublic class TreeNode implements Serializable {private Integer cid;private String cname;private Integer pid;private List nodes = new ArrayList();public TreeNode() {}//getter、setter省略}3、测试数据public class TreeNodeTest {@Testpublic void loadTree() throws Exception{System.out.println(JsonUtils.javaToJson(recursiveTree(1)));}/*** 递归算法解析成树形结构** @param cid* @return* @author jiqinlin*/public TreeNode recursiveTree(int cid) {//根据cid获取节点对象(SELECT * FROM tb_tree t WHERE t.cid=?)TreeNode node = personService.getreeNode(cid);//查询cid下的所有⼦节点(SELECT * FROM tb_tree t WHERE t.pid=?)List childTreeNodes = personService.queryTreeNode(cid);//遍历⼦节点for(TreeNode child : childTreeNodes){TreeNode n = recursiveTree(child.getCid()); //递归node.getNodes().add(n);}return node;}}输出的json格式如下：{"cid": 1,"nodes": [{"cid": 2,"nodes": [{"cid": 11,"nodes": [],"cname": "密云县","pid": 2}],"cname": "北京市","pid": 1},{"cid": 3,"nodes": [{"cid": 5,"nodes": [{"cid": 7,"nodes": [],"cname": "海珠区", "pid": 5},{"cid": 8,"nodes": [],"cname": "天河区", "pid": 5}],"cname": "⼴州市","pid": 3},{"cid": 6,"nodes": [{"cid": 9,"nodes": [],"cname": "福⽥区", "pid": 6},{"cid": 10,"nodes": [],"cname": "南⼭区", "pid": 6}],"cname": "深圳市","pid": 3}],"cname": "⼴东省","pid": 1},{"cid": 4,"nodes": [{"cid": 12,"nodes": [],"cname": "浦东","pid": 4}],"cname": "上海市","pid": 1}],"cname": "中国","pid": 0}。

java后端递归树，机构树，遍历树

java后端递归树，机构树，遍历树public static void getChildrenList(List<JSONObject> list,JSONObject pJo){List<JSONObject> retList=new ArrayList<JSONObject>();for(JSONObject jo:list){if(jo.getString("pid").equals(pJo.getString("id"))){retList.add(jo);jo.put("children", getChildrenList(list, jo));}}//return retList;pJo.put("children",retList);}第⼀种，⽅法循环⼀次，⽐较耗费内存，不建议使⽤public static void main(String[] args) {//拼装数据List<JSONObject> list=new ArrayList<JSONObject>();list.add(JSONObject.parseObject("{id:'1',name:'n1',pid:'-1'}"));list.add(JSONObject.parseObject("{id:'2',name:'n1',pid:'-1'}"));list.add(JSONObject.parseObject("{id:'3',name:'n1',pid:'-1'}"));list.add(JSONObject.parseObject("{id:'1-1',name:'n1-1',pid:'1'}"));list.add(JSONObject.parseObject("{id:'2-1',name:'n2-1',pid:'2'}"));list.add(JSONObject.parseObject("{id:'3-1',name:'n3-1',pid:'3'}"));list.add(JSONObject.parseObject("{id:'1-2',name:'n1-2',pid:'1'}"));list.add(JSONObject.parseObject("{id:'2-2',name:'n2-2',pid:'2'}"));list.add(JSONObject.parseObject("{id:'3-2',name:'n3-2',pid:'3'}"));list.add(JSONObject.parseObject("{id:'1-3',name:'n1-3',pid:'1'}"));list.add(JSONObject.parseObject("{id:'2-3',name:'n2-3',pid:'2'}"));list.add(JSONObject.parseObject("{id:'3-3',name:'n3-3',pid:'3'}"));list.add(JSONObject.parseObject("{id:'1-1-1',name:'n1-1-1',pid:'1-1'}"));list.add(JSONObject.parseObject("{id:'1-1-2',name:'n1-1-2',pid:'1-1'}"));list.add(JSONObject.parseObject("{id:'1-1-3',name:'n1-1-3',pid:'1-1'}"));//递归根节点JSONObject tJo=JSONObject.parseObject("{id:'-1',name:'根节点'}");//tJo.put("children",getChildrenList(list, tJo));System.out.println(tJo.toJSONString());//⼀次循环⽅法，⽐较好内存不建议使⽤Map<String,List<JSONObject>> map1=new HashMap<String, List<JSONObject>>();for(JSONObject jo:list){String pid=jo.getString("pid");String id=jo.getString("id");if(!map1.containsKey(pid)){//不存在map1.put(pid, new ArrayList<JSONObject>());}map1.get(pid).add(jo);if(!map1.containsKey(id)){map1.put(id, new ArrayList<JSONObject>());}jo.put("children", map1.get(id));}JSONObject tJo2=JSONObject.parseObject("{id:'-1',name:'根节点'}");tJo2.put("children", map1.get("-1"));System.out.println(tJo2.toJSONString());}第⼆种⽅法，两次循环，建议使⽤，节省内存public static void main(String[] args) {//拼装数据List<JSONObject> list=new ArrayList<JSONObject>();list.add(JSONObject.parseObject("{id:'1',name:'n1',pid:'-1'}"));list.add(JSONObject.parseObject("{id:'2',name:'n1',pid:'-1'}"));list.add(JSONObject.parseObject("{id:'3',name:'n1',pid:'-1'}"));list.add(JSONObject.parseObject("{id:'1-1',name:'n1-1',pid:'1'}"));list.add(JSONObject.parseObject("{id:'2-1',name:'n2-1',pid:'2'}"));list.add(JSONObject.parseObject("{id:'3-1',name:'n3-1',pid:'3'}"));list.add(JSONObject.parseObject("{id:'1-2',name:'n1-2',pid:'1'}"));list.add(JSONObject.parseObject("{id:'2-2',name:'n2-2',pid:'2'}"));list.add(JSONObject.parseObject("{id:'3-2',name:'n3-2',pid:'3'}"));list.add(JSONObject.parseObject("{id:'1-3',name:'n1-3',pid:'1'}"));list.add(JSONObject.parseObject("{id:'2-3',name:'n2-3',pid:'2'}"));list.add(JSONObject.parseObject("{id:'3-3',name:'n3-3',pid:'3'}"));list.add(JSONObject.parseObject("{id:'1-1-1',name:'n1-1-1',pid:'1-1'}"));list.add(JSONObject.parseObject("{id:'1-1-2',name:'n1-1-2',pid:'1-1'}"));list.add(JSONObject.parseObject("{id:'1-1-3',name:'n1-1-3',pid:'1-1'}"));//递归JSONObject tJo=JSONObject.parseObject("{id:'-1',name:'根节点'}");//tJo.put("children",getChildrenList(list, tJo));System.out.println(tJo.toJSONString());//两次循环⽅法，建议使⽤Map<String,List<JSONObject>> map=new HashMap<String, List<JSONObject>>();for(JSONObject jo:list){String pid=jo.getString("pid");if(!map.containsKey(pid)){//不存在map.put(pid, new ArrayList<JSONObject>());}map.get(pid).add(jo);}for(JSONObject jo:list){String id=jo.getString("id");if(map.containsKey(id)){jo.put("children", map.get(id));}}JSONObject tJo1=JSONObject.parseObject("{id:'-1',name:'根节点'}");tJo1.put("children", map.get("-1"));System.out.println(tJo1.toJSONString());}。

1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。

java 树结构递归
一、什么是递归
递归是一种程序设计技巧，它允许遍历树结构或其他数据结构的过程，其中一个函数指向自身，使程序能够推进下去，而不用额外的判断条件。

这种技巧的实现更简洁，因此在计算机程序设计中非常常用。

二、java树结构中的递归
1. 遍历树：树（Tree）是一种结构，它以分层的方式存储数据和操作。

在 Java 中，遍历树结构可以使用递归的方式实现，而不需要借助额外的缓冲区或栈。

2. 二叉树查找：二叉树是一种专门用于排序和搜索的数据结构，使用二叉树能够很快的定位要搜索的元素，开发人员可以使用递归来实现二叉树查找，递归的效率较高，而且编码更简洁。

3. 深度优先搜索：深度优先搜索（DFS）是一种常用的搜索算法，它是采用“先序遍历”的方式搜索一个树结构或图形，访问某个节点后，把它以及它的所有子节点都访问完才算完成一次搜索，Java 中可以使用递归的方式实现 DFS。

4. 动态规划：动态规划是一种将搜索问题分解成子问题并将子问题的结果存储在表格中的算法，使用动态规划算法可以在较低的时间复杂度内解决某些复杂的问题，在 Java 中实现动态规划可以使用递归的方式，也可以使用循环及分支的方式。

- 1 -。