只用一次集合遍历实现树形结构，非递归方式

已于 2023-07-08 20:09:18 修改
阅读量930 收藏 2
点赞数
分类专栏： Java 文章标签： java 前端 算法
于 2023-06-30 14:38:28 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Silence1515/article/details/131475371
版权

       一般情况下，我们想要实现这种无限层级的树形结构，都是采用递归的方式，但是递归比较占用内存，也容易导致栈溢出，于是只能尝试其它的方法。

        下面采用的方式，只需要一次集合的遍历就可以实现树形的结构。

 先手动编造一个树形结构的数据：

这是一个无序的树形结构数据的 json 格式：

[
  {
    "nodeId" : "700",
    "nodeDesc" : "节点700",
    "parentNodeId" : ""
  },
  {
    "nodeId" : "300",
    "nodeDesc" : "节点300",
    "parentNodeId" : ""
  },
  {
    "nodeId" : "500",
    "nodeDesc" : "节点500",
    "parentNodeId" : ""
  },
  {
    "nodeId" : "100",
    "nodeDesc" : "节点100",
    "parentNodeId" : ""
  },
  {
    "nodeId" : "400",
    "nodeDesc" : "节点400",
    "parentNodeId" : ""
  },
  {
    "nodeId" : "800",
    "nodeDesc" : "节点800",
    "parentNodeId" : ""
  },
  {
    "nodeId" : "200",
    "nodeDesc" : "节点200",
    "parentNodeId" : ""
  },
  {
    "nodeId" : "700-001",
    "nodeDesc" : "节点700-001",
    "parentNodeId" : "700"
  },
  {
    "nodeId" : "700-002",
    "nodeDesc" : "节点700-002",
    "parentNodeId" : "700"
  },
  {
    "nodeId" : "700-003",
    "nodeDesc" : "节点700-003",
    "parentNodeId" : "700"
  },
  {
    "nodeId" : "700-004",
    "nodeDesc" : "节点700-004",
    "parentNodeId" : "700"
  },
  {
    "nodeId" : "700-005",
    "nodeDesc" : "节点700-005",
    "parentNodeId" : "700"
  },
  {
    "nodeId" : "700-006",
    "nodeDesc" : "节点700-006",
    "parentNodeId" : "700"
  },
  {
    "nodeId" : "700-003-002",
    "nodeDesc" : "节点700-003-002",
    "parentNodeId" : "700-003"
  },
  {
    "nodeId" : "700-003-001",
    "nodeDesc" : "节点700-003-001",
    "parentNodeId" : "700-003"
  },
  {
    "nodeId" : "700-003-002-001",
    "nodeDesc" : "节点700-003-002-001",
    "parentNodeId" : "700-003-002"
  },
  {
    "nodeId" : "700-003-002-003",
    "nodeDesc" : "节点700-003-002-003",
    "parentNodeId" : "700-003-002"
  },
  {
    "nodeId" : "700-003-002-002",
    "nodeDesc" : "节点700-003-002-002",
    "parentNodeId" : "700-003-002"
  },
  {
    "nodeId" : "300-001",
    "nodeDesc" : "节点300-001",
    "parentNodeId" : "300"
  },
  {
    "nodeId" : "300-001-001",
    "nodeDesc" : "节点300-001-001",
    "parentNodeId" : "300-001"
  },
  {
    "nodeId" : "300-001-001-001",
    "nodeDesc" : "节点300-001-001-001",
    "parentNodeId" : "300-001-001"
  },
  {
    "nodeId" : "300-001-001-001-001",
    "nodeDesc" : "节点300-001-001-001-001",
    "parentNodeId" : "300-001-001-001"
  },
  {
    "nodeId" : "300-001-001-001-001-001",
    "nodeDesc" : "节点300-001-001-001-001-001",
    "parentNodeId" : "300-001-001-001-001"
  },
  {
    "nodeId" : "500-003",
    "nodeDesc" : "节点500-003",
    "parentNodeId" : "500"
  },
  {
    "nodeId" : "500-001",
    "nodeDesc" : "节点500-001",
    "parentNodeId" : "500"
  },
  {
    "nodeId" : "500-002",
    "nodeDesc" : "节点500-002",
    "parentNodeId" : "500"
  },
  {
    "nodeId" : "500-003-001",
    "nodeDesc" : "节点500-003-001",
    "parentNodeId" : "500-003"
  },
  {
    "nodeId" : "800-001",
    "nodeDesc" : "节点800-001",
    "parentNodeId" : "800"
  },
  {
    "nodeId" : "100-002",
    "nodeDesc" : "节点100-002",
    "parentNodeId" : "100"
  },
  {
    "nodeId" : "100-001",
    "nodeDesc" : "节点100-001",
    "parentNodeId" : "100"
  },
  {
    "nodeId" : "200-001",
    "nodeDesc" : "节点200-001",
    "parentNodeId" : "200"
  },
  {
    "nodeId" : "400-003",
    "nodeDesc" : "节点400-003",
    "parentNodeId" : "400"
  },
  {
    "nodeId" : "400-002",
    "nodeDesc" : "节点400-002",
    "parentNodeId" : "400"
  },
  {
    "nodeId" : "400-001",
    "nodeDesc" : "节点400-001",
    "parentNodeId" : "400"
  },
  {
    "nodeId" : "100-002-002",
    "nodeDesc" : "节点100-002-002",
    "parentNodeId" : "100-002"
  },
  {
    "nodeId" : "100-002-001",
    "nodeDesc" : "节点100-002-001",
    "parentNodeId" : "100-002"
  },
  {
    "nodeId" : "300-001-001-001-001-002",
    "nodeDesc" : "节点300-001-001-001-001-002",
    "parentNodeId" : "300-001-001-001-001"
  },
  {
    "nodeId" : "300-001-001-002",
    "nodeDesc" : "节点300-001-002",
    "parentNodeId" : "300-001"
  }
]

      我是在springBoot项目中测试的，通过前端页面展示数形结构的效果。

      这是后端项目结构，前端使用的 ant-design Vue 版。

   

<template>
  <div>
    <a-tree
      :show-line="true"
      :show-icon="true"
      :tree-data="treeData"
      :replaceFields="{children:'children', title:'nodeDesc', key:'nodeId' }"
      @select="onSelect"
    >
    </a-tree>
  </div>
</template>

<script>

import { queryTreeNodeList } from '@/services/myExample';
import { message } from 'ant-design-vue';

export default {
  name: 'lemonTree',

  data() {
    return {
      treeData: []
    }
  },
  created() {
    queryTreeNodeList().then(response =>{
      console.log(response, '====response====')
      this.treeData = response.data.data
    })
  },
  methods: {
    onSelect(selectedKeys, info) {
      console.log('selected', selectedKeys, info);
      // console.log('nodeDesc', info.selectedNodes[0].data.props.nodeDesc);
      message.info('您点击了：' + info.selectedNodes[0].data.props.nodeDesc);
    }
  }
}
</script>

<style scoped>

</style>

构建树形结构的核心业务代码，都写在了 service 层的这个方法里：

package com.concat.example.service;

import com.alibaba.fastjson2.JSON;
import com.concat.example.entity.LemonTreeEntity;
import org.apache.commons.io.FileUtils;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;
import org.springframework.util.ResourceUtils;
import org.springframework.util.StringUtils;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.*;
import java.util.stream.Collectors;

@Service
public class LemonTreeServiceImpl implements LemonTreeService {

    @Override
    public List<LemonTreeEntity> queryAllNodeWithTreeStructure() {
        List<LemonTreeEntity> dataSource = initLemonTree();
        // 如果要得到有顺序树状数据结构，则先进行排序操作，并且后面可以通过循环这个有序的集合组装最终的树状结构的数据；
        List<LemonTreeEntity> lemonTreeNodeList = dataSource.stream().sorted(Comparator.comparing(LemonTreeEntity::getNodeId)).collect(Collectors.toList());

        // 建立每个节点的 map 映射，方便后面快速查找到对应的节点数据；
        Map<String, LemonTreeEntity> lemonTreeNodeMap = new HashMap<>();
        lemonTreeNodeList.stream().forEach(lemonTreeEntity -> {
            String nodeId = lemonTreeEntity.getNodeId();
            lemonTreeNodeMap.put(nodeId, lemonTreeEntity);
        });


        // 结果集；
        List<LemonTreeEntity> lemonTreeResult = new ArrayList<>();

        // 循环这个有序的集合，组装最终的树状结构的数据；
        lemonTreeNodeList.stream().forEach(lemonTreeEntity -> {
            String parentNodeId = lemonTreeEntity.getParentNodeId();
            if (StringUtils.isEmpty(parentNodeId)) {
                // 说明是树的根节点，直接放在集合中；
                lemonTreeResult.add(lemonTreeEntity);
            } else {
                // 其它都是子节点，需要将每个子节点放在对应的父节点的孩子集合中。
                LemonTreeEntity parentTreeNodeEntity = lemonTreeNodeMap.get(parentNodeId);
                List<LemonTreeEntity> children = parentTreeNodeEntity.getChildren();
                if (children == null) {
                    children = new ArrayList<>();
                    parentTreeNodeEntity.setChildren(children);
                }
                children.add(lemonTreeEntity);
            }
        });

//        String json = JSON.toJSONString(lemonTreeResult);
//        System.out.println("json = " + json);
        return lemonTreeResult;
    }

    private List<LemonTreeEntity> initLemonTree() {
        File file = null;
        try {
            file = ResourceUtils.getFile("classpath:lemon_tree.json");
        } catch (FileNotFoundException e) {
            throw new RuntimeException(e);
        }
        String json = null;
        try {
            json = FileUtils.readFileToString(file, "UTF-8");
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
        System.out.println("json = " + json);
        List<LemonTreeEntity> lemonTreeEntityList = JSON.parseArray(json, LemonTreeEntity.class);
        System.out.println("lemonTreeEntityList = " + lemonTreeEntityList);

        return lemonTreeEntityList;
    }
}

package com.concat.example.entity;

import com.fasterxml.jackson.annotation.JsonInclude;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.util.List;

@Data
@JsonInclude(JsonInclude.Include.NON_EMPTY)
@NoArgsConstructor
public class LemonTreeEntity {

    private String nodeId;

    private String nodeDesc;

    private String parentNodeId;

    private List<LemonTreeEntity> children;

}

 Web项目其它相关：

package com.concat.example.vo;

import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.Accessors;
import java.io.Serializable;

@Data
@Accessors(chain = true)
@NoArgsConstructor
public class MyResponseEntity<T> implements Serializable {

    private String code;

    private String message;

    private T data;

}

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>2.3.6.RELEASE</version>
		<relativePath/> <!-- lookup parent from repository -->
	</parent>
	<groupId>com.concat.example</groupId>
	<artifactId>spring-initialize-template</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<name>spring-initialize-template</name>
	<description>Demo project for Spring Boot</description>
	<properties>
		<java.version>8</java.version>
	</properties>
	<dependencies>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter</artifactId>
		</dependency>

		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>
		</dependency>

		<dependency>
			<groupId>org.projectlombok</groupId>
			<artifactId>lombok</artifactId>
			<optional>true</optional>
		</dependency>

		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-test</artifactId>
			<scope>test</scope>
		</dependency>
		<dependency>
			<groupId>commons-io</groupId>
			<artifactId>commons-io</artifactId>
			<version>2.11.0</version>
		</dependency>

		<!-- 反序列化json字符串 -->
		<dependency>
			<groupId>com.alibaba.fastjson2</groupId>
			<artifactId>fastjson2</artifactId>
			<version>2.0.14</version>
		</dependency>
	</dependencies>

	<build>
		<plugins>
			<plugin>
				<groupId>org.springframework.boot</groupId>
				<artifactId>spring-boot-maven-plugin</artifactId>
			</plugin>
		</plugins>
	</build>

</project>

点击下载后端工程

点击下载前端工程

windfallsheng
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 3
    评论
专栏目录
如何用循环遍历树结构
sinat_34626741的博客
03-30 5191
前言：作为前端，经常遇见要处理树形结构的数据（比如菜单、树形结构的人员组织），之前常规的操作就是使用递归遍历，但最近发现递归容易出现栈溢出，所以开始思考有没有其他方式来实现遍历，既能提高性能又能避免栈溢出。 1、首先写个方法生成一个简单的树结构 function createTree(deep){ var children={}; var tree={id:0,children}; for(var i=1;i<=deep;i++){ children.id=i; children.
前端树形Tree数据结构使用-‍♂️各种姿势总结
kfashfasf的博客
02-26 1628
前端开发中会经常用到树形结构数据，如多级菜单、商品的多级分类等。数据库的设计和存储都是扁平结构，就会用到各种Tree树结构的转换操作，本文就尝试全面总结一下。如下示例数据，关键字段id为唯一标识，pid为父级id，用来标识父级节点，实现任意多级树形结构。"pid": 0“0”标识为根节点，orderNum属性用于控制排序。在前端使用的时候，如树形菜单、树形列表、树形表格、下拉树形选择器等，需要把数据转换为树形结构数据，转换后的数据结效果图：预期的树形数据结构：多了children数组存放子节点数据。
【Vue基础知识总结 5】Vue实现树形结构(2)
最新发布
2401_84092666的博客
05-07 634
效果展示：二、代码实例。
递归遍历树结构数据（js，vue）
weixin_45776308的博客
01-12 4651
【代码】递归遍历树结构数据（js）
C语言-非递归完成树的三种遍历
Jaye513的博客
11-14 786
学习两天半，我终于明白了非递归遍历树，赶快来学一学！！！
数据结构学习——树形结构之非递归遍历二叉树
weixin_53919192的博客
07-10 1326
本文为大家介绍了数据结构学习——树形结构之非递归遍历二叉树，希望对你有帮助~~
vue 树形结构数据的便捷遍历，及树形结构与平级列表的相互转换（使用xe-utils函数）
m0_63108819的博客
06-09 3185
使用xe-utils函数便捷处理树形结构数据
巧用递归函数处理循环树形结构数组
followly的博客
06-02 280
需求:首先要将每一级的nodeName与上一级的拼接起来形成一个完整的名称，最后一级的子对象还要判断其tags中是否存在第一级的areaCode，若存在，则将其取出组成一个新的数组（需要数组扁平化），最后组成新的结构返回！背景：在开发的时候遇到一个需求，后端传过来是一个树形结构数组，一层一层嵌套子级数组；这个时候需要确认最后一级里面对象中tags字段（tags:'bg001,bg002,bg003'）这样格式！巧妙解决有很多层级的数据，而不用写死循环的次数！一开始我的处理是调接口之后很呆的去手动循环三次。
一次循环实现List转树形结构（不使用递归）
weixin_37304961的博客
12-28 350
最新项目遇到了一个问题，树形结构加载时会超时，后分析后台代码发现，之前写的生成树形结构代码存在bug，当数据量不大时无法触发，一旦数据量比较大就会超时，就在想有没有什么办法能解决这个问题，通过尝试最后整理了一个以空间换时间的方法。
Vue中Json树结构递归遍历
Leonardo_zhang的博客
10-08 967
Vue中Json树结构递归遍历。
vue递归函数｜树形结构或权限
weixin_48123820的博客
05-23 463
需求是：三级联动数据，获取到的数据也是树形结构的，需要不停的往下循环，但是又不确定是几层，那么这样需要用到递归方法。
List集合数据转为树形结构（非递归）
weixin_53417222的博客
10-19 283
List集合数据转为树形结构
通过改变css使el-tree只显示第一层的复选框
m0_69502730的博客
12-02 587
通过改变css使el-tree只显示第一层的复选框
js 递归循环树形结构，根据某个节点值为节点之前，当前节点，节点之后的对象添加不同的状态值
weixin_43485503的博客
02-22 439
js 递归循环树形结构，根据某个节点值为节点之前，当前节点，节点之后的对象添加不同的值
将List转成树的两种方式(递归、循环)
热门推荐
MassiveStars的博客
12-28 4万+
在做目录树的时候通常是将一个目录存在数据库的List全部返回来，再根据节点id和parentId组装成一颗树，这里切忌使用递归查询的方式实现。List转成Tree有两种方式，一种是常用的递归，一种是双层循环。 TreeNode.java package org.massive.tree; import java.util.List; /** * Created by Massiv
JAVA将List转成Tree树形结构数据和深度优先遍历
Sinder小德的博客
11-09 1597
在日常开发中，我们经常会遇到需要将数据库中返回的数据转成树形结构的数据返回，或者需要对转为树结构后的数据绑定层级关系再返回，比如需要统计当前节点下有多少个节点等，因此我们需要封装一个ListToTree的工具类和学会如何通过深度优先遍历数据。文章仅为参考示例，更多更好的实现方式欢迎留言评论呀！先简单准备一下具有父子关系的数据。ListToTree方法。
Java通过for循环获取树形结构数据
m0_58810807的博客
10-24 4988
需求：根据所属系统表，查询到某个系统下所有部门信息，部门下面有子部门，子部门下面还有子部门。。。 然后将部门遍历出来，以树节点形式 我们知道用递归也能获得树形结构，但是用循环我觉得更加易懂，可读性会更高 话不多说，直接上代码： NoteInfo类： 两个循环进行遍历就能得结果： public NoteInfo getNoteTree(Long sysId) { // 查询出该系统下对应的部门Id List<Dept> deptList = deptDao.
转树形结构、遍历树形结构、扁平树形
m0_51431448的博客
12-22 619
这篇就是写一下平级结构与树形结构之间的转化，之前也有写过类似的：大家有兴趣可以去看一下，也算是简单巩固一下js吧。
【List＜Map＜String, Object＞＞】记录一次树形遍历方法
m0_51215376的博客
08-18 849
【List】记录一次树形遍历方法
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

windfallsheng

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

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

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

打赏作者

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

抵扣说明：

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

余额充值