java、js中实现无限层级的树形结构方法(类似递归)

js中:

var zNodes=[
{id:0,pId:-1,name:"Aaaa"},
  {id:1,pId:0,name:"A"},
  {id:11,pId:1,name:"A1"},
  {id:12,pId:1,name:"A2"},
  {id:13,pId:1,name:"A3"},
  {id:2,pId:0,name:"B"},
  {id:21,pId:2,name:"B1"},
  {id:22,pId:2,name:"B2"},
  {id:23,pId:2,name:"B3"},
  {id:3,pId:0,name:"C"},
  {id:31,pId:3,name:"C1"},
  {id:32,pId:3,name:"C2"},
  {id:33,pId:3,name:"C3"},
  {id:34,pId:31,name:"x"},
  {id:35,pId:31,name:"y"},
  {id:36,pId:31,name:"z"},
  {id:37,pId:36,name:"z1123"} ,
  {id:38,pId:37,name:"z123123123"}
];
function treeMenu(a){
  this.tree=a||[];
  this.groups={};
};
treeMenu.prototype={
  init:function(pid){
    this.group();
    return this.getDom(this.groups[pid]);
  },
  group:function(){
    for(var i=0;i<this.tree.length;i++){
      if(this.groups[this.tree[i].pId]){
        this.groups[this.tree[i].pId].push(this.tree[i]);
      }else{
        this.groups[this.tree[i].pId]=[];
        this.groups[this.tree[i].pId].push(this.tree[i]);
      }
    }
  },
  getDom:function(a){
    if(!a){return ''}
    var html='\n<ul >\n';
    for(var i=0;i<a.length;i++){
      html+='<li><a href="#">'+a[i].name+'</a>';
      html+=this.getDom(this.groups[a[i].id]);
      html+='</li>\n';
    };
    html+='</ul>\n';
    return html;
  }
};
var html=new treeMenu(zNodes).init(0);
alert(html);

java:

package test;

import java.util.ArrayList;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.Collections;

/**
 * 多叉树类
*/
public class MultipleTree {
 public static void main(String[] args) {
 // 读取层次数据结果集列表
 List dataList = VirtualDataGenerator.getVirtualResult(); 

 // 节点列表(散列表,用于临时存储节点对象)
 HashMap nodeList = new HashMap();
 // 根节点
 Node root = null;
 // 根据结果集构造节点列表(存入散列表)
 for (Iterator it = dataList.iterator(); it.hasNext();) {
  Map dataRecord = (Map) it.next();
  Node node = new Node();
  node.id = (String) dataRecord.get("id");
  node.text = (String) dataRecord.get("text");
  node.parentId = (String) dataRecord.get("parentId");
  nodeList.put(node.id, node);
 }
 // 构造无序的多叉树
 Set entrySet = nodeList.entrySet();
 for (Iterator it = entrySet.iterator(); it.hasNext();) {
  Node node = (Node) ((Map.Entry) it.next()).getValue();
  if (node.parentId == null || node.parentId.equals("")) {
  root = node;
  } else {
  ((Node) nodeList.get(node.parentId)).addChild(node);
  }
 }
 // 输出无序的树形菜单的JSON字符串
 System.out.println(root.toString());
 // 对多叉树进行横向排序
 root.sortChildren();
 // 输出有序的树形菜单的JSON字符串
 System.out.println(root.toString()); 

 // 程序输出结果如下(无序的树形菜单)(格式化后的结果):
 // {
 //  id : '100000',
 //  text : '廊坊银行总行',
 //  children : [
 //   {
 //   id : '110000',
 //   text : '廊坊分行',
 //   children : [
 //    {
 //    id : '113000',
 //    text : '廊坊银行开发区支行',
 //    leaf : true
 //    },
 //    {
 //    id : '111000',
 //    text : '廊坊银行金光道支行',
 //    leaf : true
 //    },
 //    {
 //    id : '112000',
 //    text : '廊坊银行解放道支行',
 //    children : [
 //     {
 //     id : '112200',
 //     text : '廊坊银行三大街支行',
 //     leaf : true
 //     },
 //     {
 //     id : '112100',
 //     text : '廊坊银行广阳道支行',
 //     leaf : true
 //     }
 //    ]
 //    }
 //   ]
 //   }
 //  ]
 // }

 // 程序输出结果如下(有序的树形菜单)(格式化后的结果):
 // {
 //  id : '100000',
 //  text : '廊坊银行总行',
 //  children : [
 //   {
 //   id : '110000',
 //   text : '廊坊分行',
 //   children : [
 //    {
 //    id : '111000',
 //    text : '廊坊银行金光道支行',
 //    leaf : true
 //    },
 //    {
 //    id : '112000',
 //    text : '廊坊银行解放道支行',
 //    children : [
 //     {
 //     id : '112100',
 //     text : '廊坊银行广阳道支行',
 //     leaf : true
 //     },
 //     {
 //     id : '112200',
 //     text : '廊坊银行三大街支行',
 //     leaf : true
 //     }
 //    ]
 //    },
 //    {
 //    id : '113000',
 //    text : '廊坊银行开发区支行',
 //    leaf : true
 //    }
 //   ]
 //   }
 //  ]
 // } 

 }

}

/**
* 节点类
*/
class Node {
 /**
 * 节点编号
 */
 public String id;
 /**
 * 节点内容
 */
 public String text;
 /**
 * 父节点编号
 */
 public String parentId;
 /**
 * 孩子节点列表
 */
 private Children children = new Children();

 // 先序遍历,拼接JSON字符串
 public String toString() {
 String result = "{"
  + "id : '" + id + "'"
  + ", text : '" + text + "'";

 if (children != null && children.getSize() != 0) {
  result += ", children : " + children.toString();
 } else {
  result += ", leaf : true";
 }

 return result + "}";
 }

 // 兄弟节点横向排序
 public void sortChildren() {
 if (children != null && children.getSize() != 0) {
  children.sortChildren();
 }
 }

 // 添加孩子节点
 public void addChild(Node node) {
 this.children.addChild(node);
 }
}

/**
* 孩子列表类
*/
class Children {
 private List list = new ArrayList();

 public int getSize() {
 return list.size();
 }

 public void addChild(Node node) {
 list.add(node);
 }

 // 拼接孩子节点的JSON字符串
 public String toString() {
 String result = "[";
 for (Iterator it = list.iterator(); it.hasNext();) {
  result += ((Node) it.next()).toString();
  result += ",";
 }
 result = result.substring(0, result.length() - 1);
 result += "]";
 return result;
 }

 // 孩子节点排序
 public void sortChildren() {
 // 对本层节点进行排序
 // 可根据不同的排序属性,传入不同的比较器,这里传入ID比较器
 Collections.sort(list, new NodeIDComparator());
 // 对每个节点的下一层节点进行排序
 for (Iterator it = list.iterator(); it.hasNext();) {
  ((Node) it.next()).sortChildren();
 }
 }
}

/**
 * 节点比较器
 */
class NodeIDComparator implements Comparator {
 // 按照节点编号比较
 public int compare(Object o1, Object o2) {
 int j1 = Integer.parseInt(((Node)o1).id);
   int j2 = Integer.parseInt(((Node)o2).id);
   return (j1 < j2 ? -1 : (j1 == j2 ? 0 : 1));
 }
}

/**
 * 构造虚拟的层次数据
 */
class VirtualDataGenerator {
 // 构造无序的结果集列表,实际应用中,该数据应该从数据库中查询获得;
 public static List getVirtualResult() {
 List dataList = new ArrayList();

 HashMap dataRecord1 = new HashMap();
 dataRecord1.put("id", "112000");
 dataRecord1.put("text", "廊坊银行解放道支行");
 dataRecord1.put("parentId", "110000");

 HashMap dataRecord2 = new HashMap();
 dataRecord2.put("id", "112200");
 dataRecord2.put("text", "廊坊银行三大街支行");
 dataRecord2.put("parentId", "112000");

 HashMap dataRecord3 = new HashMap();
 dataRecord3.put("id", "112100");
 dataRecord3.put("text", "廊坊银行广阳道支行");
 dataRecord3.put("parentId", "112000");

 HashMap dataRecord4 = new HashMap();
 dataRecord4.put("id", "113000");
 dataRecord4.put("text", "廊坊银行开发区支行");
 dataRecord4.put("parentId", "110000");

 HashMap dataRecord5 = new HashMap();
 dataRecord5.put("id", "100000");
 dataRecord5.put("text", "廊坊银行总行");
 dataRecord5.put("parentId", "");

 HashMap dataRecord6 = new HashMap();
 dataRecord6.put("id", "110000");
 dataRecord6.put("text", "廊坊分行");
 dataRecord6.put("parentId", "100000");

 HashMap dataRecord7 = new HashMap();
 dataRecord7.put("id", "111000");
 dataRecord7.put("text", "廊坊银行金光道支行");
 dataRecord7.put("parentId", "110000"); 

 dataList.add(dataRecord1);
 dataList.add(dataRecord2);
 dataList.add(dataRecord3);
 dataList.add(dataRecord4);
 dataList.add(dataRecord5);
 dataList.add(dataRecord6);
 dataList.add(dataRecord7);

 return dataList;
 }
}

以上这篇java、js中实现无限层级的树形结构方法(类似递归)就是小编分享给大家的全部内容了,希望能给大家一个参考,也希望大家多多支持我们。

时间: 2016-11-03

java实现构造无限层级树形菜单

这里来讲一下后台java如何构造多叉树,这样前台就可接收到数据递归构造树形菜单了. 我们来理一下如何实现构造多叉树的逻辑吧,其实整个问题概括起来就是 1.构造一个实体类,用来存储节点,所以我们构造的需要四个对象(id,pid,name,和chirenList) 2.构造菜单结构 3.构造子菜单,如此循环,通过pid判断上级菜单 具体实现: 1.这里构造Tree.java实体类 package com.tcl.jr.crm.entity; /** * 类名称:Tree * 类描述:树形结构 */

Java递归如何正确输出树形菜单

本文实例为大家分享了java递归输出树形菜单的具体代码,供大家参考,具体内容如下 首先我们要建立树节点的类: package com.tree; public class Node { private Integer id; private Integer parentId; private String name; private String link; public Integer getId() { return id; } public void setId(Integer id) {

JS无限极树形菜单,json格式、数组格式通用示例

修改了一下数据格式,是json和数组或者混合型的数据都通用,不用特定key等 复制代码 代码如下: <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> <html xmlns="http://www.w3.org/1999/xhtml"&g

java利用递归调用实现树形菜单的样式

一:需求 现有以需求就是把某一个帖子的全部评论展示出来. 二:分析 关于对帖子的评论分为主评论和子评论,主评论就是对帖子的直接评论,子评论就是对评论的评论. 三:思路 先获取某一个帖子的全部主评论,递归判断是否有子评论,获取子评论. 递归本质:程序调用自身的编程技巧叫做递归. 程序调用自身的编程技巧称为递归( recursion).递归做为一种算法在程序设计语言中广泛应用. 一个过程或函数在其定义或说明中有直接或间接调 用自身的一种方法,它通常把一个大型复杂的问题层层转化为一个与原问题相似的规模

js实现无限层级树形数据结构(创新算法)

由于做项目的需要,把一个线性数组转成树形数组,在网上查了很多文章,觉得他们写的太复杂了,于是自己写了一个,在折腾了一下午终于把它写出来啦(激动.gif),用两个filter过滤器就搞定了,代码简洁明了,数据结构小白都能看懂. js代码:把扁平数据转成树形数据 function setTreeData(source){ let cloneData = JSON.parse(JSON.stringify(source)) // 对源数据深度克隆 return cloneData.filter(fat

Java构建树形菜单的实例代码(支持多级菜单)

效果图:支持多级菜单. 菜单实体类: public class Menu { // 菜单id private String id; // 菜单名称 private String name; // 父菜单id private String parentId; // 菜单url private String url; // 菜单图标 private String icon; // 菜单顺序 private int order; // 子菜单 private List<Menu> children;

Java树形菜单的创建

功能:实现创建一个树形菜单 说明:创建树形菜单结构与创建菜单栏类似,是按层次与模型创建的. 通过DefaultMutableTreeNode类创建根节点.子节点和孙节点对象,再通过DefaultTreeModel 类利用根节点创建树模型对象,然后通过treeModel.insertNodeInto方法将节点对象插入树模型中. 效果图: 代码: import java.awt.*; import javax.swing.*; import javax.swing.tree.*; import ja

java实现遍历树形菜单两种实现代码分享

文本主要向大家分享了java实现遍历树形菜单的实例代码,具体如下. OpenSessionView实现: package org.web; import java.io.IOException; import javax.servlet.Filter; import javax.servlet.FilterChain; import javax.servlet.FilterConfig; import javax.servlet.ServletException; import javax.se

java编程两种树形菜单结构的转换代码

首先看看两种树形菜单结构的代码示例. SingleTreeNode: package com.zzj.tree; public class SingleTreeNode { private int id; private int pId; private String name; public SingleTreeNode() { } public SingleTreeNode(int id, int pId, String name) { this.id = id; this.pId = pI