如何用Java实现树形结构啊？
[java] view plain copy
package com.tree.test;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
public class Test {
public static void main(String[] args){
showTree();
}
public static void showTree(){
Connection conn=null;
ResultSet rs = null;
Statement stmt=null;
try {
Class.forName("com.mysql.jdbc.Driver");
conn=DriverManager.getConnection("jdbc:mysql://localhost/tree?user=root&password=root");
/*stmt=conn.createStatement();
rs=stmt.executeQuery("select * from country where pid=0");
while(rs.next()){
System.out.println(rs.getString("actile"));*/
tree(conn,0,0);
// }
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}finally {
try {
if(rs != null) {
rs.close();
rs = null;
}
if(stmt != null) {
stmt.close();
stmt = null;
}
if(conn != null) {
conn.close();
conn = null;
}
} catch (SQLException e) {
e.printStackTrace();
}
}
}
public static void tree(Connection conn,int id,int level){
Statement stmt = null;
ResultSet rs = null;
try {
stmt = conn.createStatement();
String sql = "select * from country where pid = " + id;
rs = stmt.executeQuery(sql);
while(rs.next()) {
StringBuffer strPre = new StringBuffer("");
for(int i=0; i<level; i++) {
strPre.append(" ");
}
System.out.println(strPre + rs.getString("actile"));
if(rs.getInt("is_leaf") != 0)
tree(conn, rs.getInt("id"), level + 1);
}
} catch (SQLException e) {
e.printStackTrace();
} finally {
try {
if(rs != null) {
rs.close();
rs = null;
}
if(stmt != null) {
stmt.close();
stmt = null;
}
} catch (SQLException e) {
e.printStackTrace();
}
}
}
数据库
[sql] view plain copy
create database tree;
use tree;
create table country
(
id int primary key auto_increment,
pid int,
actile varchar(40),
is_leaf int
);
insert into country values(1,0, '中国',1);
insert into country values(2,1,'北京',0);
insert into country values(3,0,'美国',1);
insert into country values(4,3,'纽约',0);
insert into country values(5,1,'浙江',1);
insert into country values(6,5,'杭州',1);
insert into country values(7,6,'滨江',0);
你针对这个表写个实体类，写出它的dao，然后取出所有数据放到List，把list放到request.setAttribute("all");在请求到的页面中用getAttribute取出，然后用js写DOM模型表示出来，js中的引用可以直接使用java的数据，例如：<%
List l = (List)request.getAttribute("all");
for(int i==0;i<l.size();i++){
实体类 a = ( 实体类)l.get(i);
%>
var url =
<%
}
%>
DOM模型可以使js更好的控制我们想要实现的效果
import java.util.LinkedList;
import java.util.List;
/**
* 功能：把一个数组的值存入二叉树中，然后进行3种方式的遍历
*
* 参考资料0:数据结构(C语言版)严蔚敏
*
* 参考资料1：http://zhidao.baidu.com/question/81938912.html
*
* 参考资料2：http://cslibrary.stanford.edu/110/BinaryTrees.html#java
*
* @author ocaicai@yeah.net @date: 2011-5-17
*
*/
public class BinTreeTraverse2 {
private int[] array = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
private static List<Node> nodeList = null;
/**
* 内部类：节点
*
* @author ocaicai@yeah.net @date: 2011-5-17
*
*/
private static class Node {
Node leftChild;
Node rightChild;
int data;
Node(int newData) {
leftChild = null;
rightChild = null;
data = newData;
}
}
public void createBinTree() {
nodeList = new LinkedList<Node>();
// 将一个数组的值依次转换为Node节点
for (int nodeIndex = 0; nodeIndex < array.length; nodeIndex++) {
nodeList.add(new Node(array[nodeIndex]));
}
// 对前lastParentIndex-1个父节点按照父节点与孩子节点的数字关系建立二叉树
for (int parentIndex = 0; parentIndex < array.length / 2 - 1; parentIndex++) {
// 左孩子
nodeList.get(parentIndex).leftChild = nodeList
.get(parentIndex * 2 + 1);
// 右孩子
nodeList.get(parentIndex).rightChild = nodeList
.get(parentIndex * 2 + 2);
}
// 最后一个父节点:因为最后一个父节点可能没有右孩子，所以单独拿出来处理
int lastParentIndex = array.length / 2 - 1;
// 左孩子
nodeList.get(lastParentIndex).leftChild = nodeList
.get(lastParentIndex * 2 + 1);
// 右孩子,如果数组的长度为奇数才建立右孩子
if (array.length % 2 == 1) {
nodeList.get(lastParentIndex).rightChild = nodeList
.get(lastParentIndex * 2 + 2);
}
}
/**
* 先序遍历
*
* 这三种不同的遍历结构都是一样的，只是先后顺序不一样而已
*
* @param node
* 遍历的节点
*/
public static void preOrderTraverse(Node node) {
if (node == null)
return;
System.out.print(node.data + " ");
preOrderTraverse(node.leftChild);
preOrderTraverse(node.rightChild);
}
/**
* 中序遍历
*
* 这三种不同的遍历结构都是一样的，只是先后顺序不一样而已
*
* @param node
* 遍历的节点
*/
public static void inOrderTraverse(Node node) {
if (node == null)
return;
inOrderTraverse(node.leftChild);
System.out.print(node.data + " ");
inOrderTraverse(node.rightChild);
}
/**
* 后序遍历
*
* 这三种不同的遍历结构都是一样的，只是先后顺序不一样而已
*
* @param node
* 遍历的节点
*/
public static void postOrderTraverse(Node node) {
if (node == null)
return;
postOrderTraverse(node.leftChild);
postOrderTraverse(node.rightChild);
System.out.print(node.data + " ");
}
public static void main(String[] args) {
BinTreeTraverse2 binTree = new BinTreeTraverse2();
binTree.createBinTree();
// nodeList中第0个索引处的值即为根节点
Node root = nodeList.get(0);
System.out.println("先序遍历：");
preOrderTraverse(root);
System.out.println();
System.out.println("中序遍历：");
inOrderTraverse(root);
System.out.println();
System.out.println("后序遍历：");
postOrderTraverse(root);
}
}
定义一个简单的菜单类 这里是简单的示例 你可以自行扩展package entity;import java.util.ArrayList;
import java.util.List;/**
* 菜单类
* @author Administrator
*
*/
public class Menu {
/**
* 菜单标题
*/
private String title;
/**
* 子菜单的集合
*/
private List<Menu> childs;
/**
* 父菜单
*/
private Menu parent;
/**
* 构造函数 初始化标题和子菜单集合
*/
public Menu(String title) {
this();
this.title=title;
}
/**
* 构造函数 创建一个虚拟的父菜单(零级菜单) 所有的一级菜单都归属于一个虚拟的零级菜单
*
*/
public Menu() {
this.childs = new ArrayList<Menu>();
}
/**
* 获取子菜单
* @return
*/
public List<Menu> getChilds() {
return childs;
}
/**
* 获取标题
* @return
*/
public String getTitle() {
return title;
}
/**
* 获取父菜单
* @return
*/
public Menu getParent() {
return parent;
}
/**
* 添加子菜单并返回该子菜单对象
* @param child
* @return
*/
public Menu addChild(Menu child){
this.childs.add(child);
return child;
}
/**
* 设置父菜单
* @param parent
*/
public void setParent(Menu parent) {
this.parent = parent;
}
/**
* 设置标题
* @param title
*/
public void setTitle(String title) {
this.title = title;
}
} 测试package entity;
/**
* 测试类
* @author Administrator
*
*/
public class Test { /**
* @param args
*/
public static void main(String[] args) {
/**
* 创建一个虚拟的父菜单 用于存放一级菜单 menu01 和 menu02
*/
Menu root = new Menu();
/**
* 创建两个一级菜单
*/
Menu menu01 = new Menu("一级菜单01");
Menu menu02 = new Menu("一级菜单02");
/**
* 加入虚拟菜单
*/
root.addChild(menu01);
root.addChild(menu02);
/**
* 为两个一级菜单分别添加两个子菜单 并返回该子菜单 需要进一步处理的时候 才接收返回的对象 否则只要调用方法
*/
Menu menu0101 = menu01.addChild(new Menu("二级菜单0101"));
menu01.addChild(new Menu("二级菜单0102"));
menu02.addChild(new Menu("二级菜单0201"));
Menu menu0202 = menu02.addChild(new Menu("二级菜单0202"));
/**
* 添加三级菜单
*/
menu0101.addChild(new Menu("三级菜单010101"));
menu0202.addChild(new Menu("三级菜单020201"));
/**
* 打印树形结构
*/
showMenu(root);
} /**
* 递归遍历某个菜单下的菜单树
*
* @param menu
* 根菜单
*/
private static void showMenu(Menu menu) {
for (Menu child : menu.getChilds()) {
showMenu(child, 0);
}
} private static void showMenu(Menu menu, int tabNum) {
for (int i = 0; i < tabNum; i++)
System.out.print("\t");
System.out.println(menu.getTitle());
for (Menu child : menu.getChilds())
// 递归调用
showMenu(child, tabNum + 1);
}}
控制台输出结果 一级菜单01 二级菜单0101
三级菜单010101
二级菜单0102一级菜单02
二级菜单0201
二级菜单0202
三级菜单020201
楼主是不是在学Java se的，如果是的话，我记得在awt还是Swing中有一章是专门介绍树的好像Java类库中有专门的一个Tree类是完成这种功能的。
简单树
public static void main (String [] args) {
Display display = new Display ();
Shell shell = new Shell (display);
shell.setLayout(new FillLayout());
final Tree tree = new Tree (shell, SWT.BORDER);
for (int i=0; i<4; i++) {
TreeItem iItem = new TreeItem (tree, 0);
iItem.setText ("TreeItem (0) -" + i);
for (int j=0; j<4; j++) {
TreeItem jItem = new TreeItem (iItem, 0);
jItem.setText ("TreeItem (1) -" + j);
for (int k=0; k<4; k++) {
TreeItem kItem = new TreeItem (jItem, 0);
kItem.setText ("TreeItem (2) -" + k);
for (int l=0; l<4; l++) {
TreeItem lItem = new TreeItem (kItem, 0);
lItem.setText ("TreeItem (3) -" + l);
}
}
}
}
shell.setSize (200, 200);
shell.open ();
while (!shell.isDisposed()) {
if (!display.readAndDispatch ()) display.sleep ();
}
display.dispose ();
}
楼主参考一下吧！
/**
* 树形结构 ext 脚本递归算法
* */
private String builderPrivileges(String index, List<PrivilegesEntity> list,
HttpServletRequest request) {
StringBuffer role = new StringBuffer();
role.append("[ ");
int listSize = list.size();
boolean bs = false;
for (int i = 0; i < listSize; i++) {
PrivilegesEntity xtgl_cxdy = list.get(i);
//
if (xtgl_cxdy.getPARENTID().equals(index)) {
role.append("{ ");
bs = true;
role.append("id:'").append(xtgl_cxdy.getCXID()).append("',")
.append("text:'").append(xtgl_cxdy.getNAME());
role.append("'").append(",leaf:true,href:'").append(
request.getContextPath());
role.append("/").append(
"menupage.action?menu.MENUID=" + xtgl_cxdy.getCXID())
.append("',hrefTarget:'main'");
if (xtgl_cxdy.getISLEAF().equals("0")) {
role.append(",leaf:false,children:");
role.append(builderPrivileges(xtgl_cxdy.getCXID(), list,
request));
}
role.append("}").append(",");
}
}
if (!bs) {
return "[]";
}
return role.substring(0, role.length() - 1) + " ] ";
}
美工做的,html就行代码
java如何导入excel文件在页面显示树结构
答：1. 要正确的将Web客户端的Excel文件导入到服务器的数据库中，需要将客户端的Excel文件上传到服务器上。可以使用FileUpload控件完成。 2. Excel文件上传到服务器指定的目录中，这里假设是该站点的upfiles目录中。 3. 使用SQL...
用JAVA写二叉树
答：Tree2Bef();String mid="84925163A7B";String bef="894526AB731";System.out.println(tree.getBef(mid,bef));} } 树结构如图:1 |---| 2 3 |---| |---| 4 5 6 7 |-| |-| 8 9 A B ...
java从数据库中查询数据,存储为树形结构,怎么做?
答：解决方法很多!数据要存储为树形结构，那么数据要有父子关系。一个父节点有多个子节点，一个子节点又有多个子子节点。publicclassTreeNode{ /**节点主键**/ privateStringid;/**节点名称**/ privateStringtext;/**子节点*...
JAVA画树
答：依次重新对孩子的X和Y赋值 children.get(i).x = distanceX;children.get(i).y = distanceY;paint(children.get(i));} } } 这样就可以在另一个类里通过添加这样的treenode实现上面的树形结构了。
java界面编程实现展开树
答：使用JTree 给你个例子import javax.swing.*;import java.awt.*;import java.awt.event.*;import java.util.*;public class TreeDemo1{ public TreeDemo1(){ JFrame f=new JFrame("TreeDemo1");Container contentPane...
java怎么对树形结构进行遍历
答：java">import java.util.Iterator;import java.util.Random;import java.util.TreeSet;public class Demo{ public static void main(String[] args) throws Exception { TreeSet<Integer> ts = new TreeSet<Integer>();f...
如何用Java的方式设计一个后序线索二叉树的方法?
答：在Java中，你可以定义一个类来表示后序线索二叉树，其中包含有头节点、尾节点和当前节点指针。你可以使用递归或迭代方法遍历整棵树，并创建线索，即存储前驱和后继节点的指针。当访问到叶子节点时，需要将尾节点的指针指向它...
java实现二叉树的问题
答：//用于标志二叉树节点在数组中的存储位置，以便在创建二叉树时能够找到节点对应的数据。static int index;//构造函数 public BitTree() { System.out.print("测试二叉树的顺序表示为：");System.out.println(treeLine);thi...
Java二叉树构造问题 要求:从控制台输入一行扩展二叉树的字符串,然后根...
答：树类：package tree;import java.util.List;public class Tree { private int parentId;private int id;private String showStr;private String Spaces="";public Tree() { // TODO Auto-generated constructor stub } pu...
java数据保存类似树形的数据结构
答：》其子节点，etc。 但是这种结构要有存的时候要循环一遍排成上述的顺序，取的时候还需要判断哪个是下一个不同级节点的开始。js前台展示比较简单，根据父id直接添加就行了，原数据什么都不用做。但是java里这种方式不行。
