寻求一个算法~！200分的问题，谁解决就是谁的！

[bxh2dai]

我数据库里有一个表结构是这样的：
ID parentID name
1 0 第一
2 0 第二
3 1 一的孩子
4 2 二的孩子
5 3 一的孩子的孩子

其中，ID是自增ID，parentID是代表他的父类是那一个，0为最高的，name就是他的名字！
我想同过这个表在JSP面得到这样的显示：
第一
一的孩子
一的孩子的孩子
第二
二的孩子
我想一天了，还是没有不知道怎么写，我使用递归，但是我写是时候突然发现，我递归完“第一”后，“第二”怎么办，可能重复递归的，请高手指教~！
我愿意再给100分~！
如果谁解决了，此贴的另一个分也一起为~！
http://community.csdn.net/Expert/topic/3254/3254903.xml?temp=.4085962

[bxh2dai]

to chancelin() :
多谢你的帮助，可是都看得我头都大了！
呵呵

[AHUA1001]

这是一个树型算法，看看这个吧。
http://community.csdn.net/Expert/topic/3190/3190905.xml?temp=.6056177
http://community.csdn.net/Expert/topic/3157/3157582.xml?temp=.8795435

[bxh2dai]

顶一下~！

[gnodiew]

很容易啊!

[dvictor]

去找个tag lib用用 比自己写简单
比如jsptree，ninebit,WebTree,XTree等等

[angelheart]

为一下会不会有这种情况？

ID parentID
1 0
2 0
3 1
4 1
5 1
6 2
. .
. .
. .

[gnodiew]

看你显示方式了，如果你有一个好用的tree脚本，只要把父结点ID给它就可以了
另外你可以考虑改一下你的数据结构，好的结构可以使问题更清晰，简单
如
Code Name
001 1
002 2
001001 1.1
001002 1.2
002001 2.1
001001001 1.1.1
....
处理起来就给你那个要简单多了

[bxh2dai]

数据表结构是不能改的~！

[诗海]

这个可以使用XML来解决.(具体使用可以参看XML类)
首先创建一个xml,跟节点为0
以后每碰到一个节点,就搜索其父节点,并插入.
生成XML以后,使用就相当方便了,遍历一次就可以正确显示了.
(呵呵,直接把XML生成.XML文件显示出来就可以满足要求:)

[happyegg]

我在你的另一个贴里面贴了伪代码，如果你希望通过学习来学会而不是就是为了copy代码的话，会对你有帮助的

[angelheart]

import com.JDBC; //jdbc连接类

public Collection Myfunction(int id) {

List list = new ArrayList();
try {
ResultSet rs;
JDBC jdbc = new JDBC();
rs =
jdbc.executeQuery(
"select id from x where x.id=2 and x.id=x.parentid");
list = (List) findparent(rs,list);
} catch (Exception e) {
System.out.println(e.getMessage());
}
return list;
}

private Collection findparent(ResultSet rs,List list) {
int id;
try {
JDBC jdbc = new JDBC();
while (rs.next()) {
id = rs.getInt("id");
rs =
jdbc.executeQuery(
"select id from x where x.id="
+ id
+ " and x.id=x.parentid");
if (!rs.next())
return list;
else {
id = rs.getInt("id");
if(!list.contains(new Integer(id)))
list.add(new Integer(id));
while(rs.next()) {
id = rs.getInt("id");
if(list.contains(new Integer(id))) continue;
list.add(new Integer(id));
}
list = (List)findparent(rs,list);
}
}
} catch (Exception e) {
System.out.println(e.getMessage());
}
return list;
}
}


这个是传入ID（这里是第一的ID）后把ID的后代全部放入list，既然ID是自增的，把不属于list的最小的ID就是“第二”，当然你要执行一下sql操作,把最大的ID取出来作为结束条件

[charmguy]

以前回答类似的问题时写了一个，没测过，不知道是否可以，

public String getPath(String parentId)
throws Exception
{
Connection conn = null;
PreparedStatement pstmt = null;
ResultSet rs = null;
try
{
conn = DriverManager.getConnection();
String query = "select id, parentId, name from table where parentId = ? ";
pstmt.setString(1, parentId);
pstmt = conn.prepareStatement(query);
rs = pstmt.executeQuery();
if (rs.next())
return rs.getString("name") + "\n\t" + getPath(rs.getString("id"));
else
return "\n";
}
catch (SQLException se)
{
throw new Exception(se);
}
finally
{
if (rs != null)
try { rs.close(); } catch (Exception e) {}
if (pstmt != null)
try { pstmt.close(); } catch (Exception e) {}
if (conn != null)
try { conn.close(); } catch (Exception e) {}
}
}

[angelheart]

刚才的有点错误~~应该是不属于list且此id的parentid为0的时候此ID为“第二”

[wing120]

嘿嘿……
有意思啊

[zaife]

oracle 中
SELECT [LEVEL], column, expression, ...
FROM table
[WHERE where_clause]
[[START WITH start_condition] [CONNECT BY PRIOR prior_condition]];
可以查询树状结构

[figoren]

我也遇到过类似问题
库结构和你一样 找出一个父节点下所以字节点的方法
public class FindTree
{
String strSql="";
ResultSet rs=null;
ArrayList list=new ArrayList();
//通过父节点找出所有子节点
public void getId(String fid)
{
try{
int temp1=0; //初始化临时变量
int temp2=0;
int temp3=0;
DBConnect db=new DBConnect();
//增加所要寻找的父节点
list.add(fid);
while(true)
{
temp2=list.size(); //保存list中的长度值 第一次为1

temp1=temp3;

//保存新的循环位置 第一次为0 第2次为上次长度位置

for(int i=temp1;i<temp2;i++) //从list中循环找出节点
{
strSql="select id from tre where parentid='"+list.get(i).toString()+"' ";

rs=db.executeQuery(strSql);

while(rs.next())
{
list.add(rs.getString("id")); //将从数据库中找到的字节点在加入list中
}
}
temp3=temp2; //保存上次的list长度

temp1=list.size(); //再次取出新的list长度
//若新的与上次的长度一样说明数据库没有字节点了 循环退出

if(temp1==temp2) break;

}
//list中存放的就是fid的所有字节点
for(int i=0;i<list.size();i++)
{
System.out.println("childern is"+" "+list.get(i).toString());
}
}
catch(Exception e)
{
System.out.println("Error"+e.toString());
}
}

[chancelin]

public class Tree implements java.io.Serializable{
private java.util.Hashtable m_nodes=new java.util.Hashtable();
public Node add(String id,String text){
return add(id,text,0,0,(Node)null);
}
public Node add(String id,String text,int value){
return add(id,text,value,0,(Node)null);
}
public Node add(String id,String text,Node parent){
return add(id,text,0,0,parent);
}
public Node add(String id,String text,String parent_id){
return add(id,text,0,0,findNode(parent_id));
}
public Node add(String id,String text,int value,Node parent){
return add(id,text,value,0,parent);
}
public Node add(String id,String text,int value,String parent_id){
if(parent_id!=null &&!parent_id.equals("")&& findNode(parent_id)==null) return null;
return add(id,text,value,0,findNode(parent_id));
}
public Node add(String id,String text,int value,int order){
return add(id,text,value,order,(Node)null);
}
public Node add(String id,String text,int value,int order,Node parent){
if(parent!=null&&m_nodes.get(parent.getId())==null)return null;
Node n=new Node(id,text,value,order,parent);
this.m_nodes.put(id,n);
return n;
}
public Node add(String id,String text,int value,int order,String parent_id){
return add(id,text,value,order,findNode(parent_id));
}

public Node findNode(String id){
return (Node)m_nodes.get(id);
}
public void delete(String id){
m_nodes.remove(id);
}
public void delete(Node n){
java.util.Enumeration nodes=this.getSubNodes(n);
while(nodes.hasMoreElements())
delete((Node)nodes.nextElement());
m_nodes.remove(n.getId());
}
public int count(){
return m_nodes.size();
}
public java.util.Enumeration getTopNodes(){
return getSubNodes(null);
}
public java.util.Enumeration getSubNodes(Node parent){
java.util.Vector subNodes=new java.util.Vector();
java.util.Enumeration e=m_nodes.elements();
while(e.hasMoreElements()){
Node n=(Node)e.nextElement();
if(n.getParent()==parent)
subNodes.add(n);
}
return subNodes.elements();
}
public java.util.Enumeration getSubNodes(Node parent,boolean isDesc){
java.util.Vector v=new java.util.Vector();
java.util.Enumeration e=getSubNodes(parent);
int index=0;
while(e.hasMoreElements()){
Node n=(Node)e.nextElement();
int i=0;
for(i=0;i<v.size();i++){
int cmp=compare((Node)v.get(i),n);
if( (cmp<=0 && isDesc) || (cmp>=0 && !isDesc))break;
}
v.insertElementAt(n,i);
}
return v.elements();
}
public java.util.Enumeration getTailNodes(){
java.util.Hashtable nodes=(java.util.Hashtable)m_nodes.clone();
java.util.Enumeration e=nodes.elements();
while(e.hasMoreElements()){
Node n=(Node)e.nextElement();
if(n!=null)n=n.getParent();
if(n!=null)nodes.remove(n.getId());
}
return nodes.elements();
}
public int getValue(Node n){
return n.getValue();
}
public int getValues(Node n){
int v=0;
Node p=n;
while(p!=null){
v+=p.getValue();
p=p.getParent();
}
return v;
}
public int getMaxValue(){
int v=0;
int v1=0;
java.util.Enumeration e=m_nodes.elements();
while(e.hasMoreElements()){
v1=getValue((Node)e.nextElement());
if(v<v1)v=v1;
}
return v;
}
public int getMaxValues(){
int v=0;
int v1=0;
java.util.Enumeration e=m_nodes.elements();
while(e.hasMoreElements()){
v1=getValues((Node)e.nextElement());
if(v<v1)v=v1;
}
return v;
}
public int getDeep(Node n){
int deep=0;
Node p=n;
while(p!=null){
deep++;
p=p.getParent();
}
return deep;
}
public int getMaxDeep(){
int v=0;
int v1=0;
java.util.Enumeration e=m_nodes.elements();
while(e.hasMoreElements()){
v1=getDeep((Node)e.nextElement());
if(v<v1)v=v1;
}
return v;
}
public Node getParentNode(Node n){
return n.getParent();
}
public boolean isTailNode(Node n){
return !this.getSubNodes(n).hasMoreElements();
}
public java.util.Enumeration getNodes(){
return m_nodes.elements();
}
public String getNodeFullText(String s){
return getNodeFullText(findNode(s));
}
public String getNodeFullText(Node n){
if(n!=null){
if(n.getParent()!=null)
return getNodeFullText(n.getParent())+" - "+n.getText();
return n.getText();
}
return "";
}
public Tree getSubTree(Node top){
Tree tree=new Tree();
tree.add(top.getId(),top.getText(),top.getValue());
addSubNodes(tree,top.getId());
return tree;
}
private void addSubNodes(Tree tree,String parent){
if(findNode(parent)==null)return;
java.util.Enumeration e=this.getSubNodes(findNode(parent));
while(e.hasMoreElements()){
Node n=(Node)e.nextElement();
tree.add(n.getId(),n.getText(),n.getValue(),parent);
addSubNodes(tree,n.getId());
}
}
private int compare(Node n1,Node n2){
if(n1.getOrder()==n2.getOrder())return 0;
if(n1.getOrder()>n2.getOrder())return 1;
return -1;
}
}

[chancelin]

这是主方法和递归调用方法：
static public void print(Tree t,Node n,int deep){
java.util.Enumeration nodes=t.getSubNodes(n,false);
for(int i=0;i<deep;i++)System.out.print("\t");
if(n!=null)System.out.println(n.getId()+"-"+n.getText()+","+n.getValue());
while(nodes.hasMoreElements())
print(t,(Node)nodes.nextElement(),deep+1);
}

static public void main(String[] argv){
Tree t=new Tree();
Node root=t.add("root","Root",10);
t.add("Sub1","Sub item 1",5,root);
t.add("root1","root 1",10);
Node sub2=t.add("sub2","Sub Item 2",5,root);
Node sub3=t.add("sub3","Sub Item 3",5,root);
Node sub4=t.add("sub4","Sub Item 4",5,root);
Node sub5=t.add("sub5","Sub Item 5",5,root);
Node sub6=t.add("sub6","Sub Item 6",5,root);
t.add("sub2sub1","Sub Item 2/1",3,sub2);
t.add("sub2sub2","Sub Item 2/2",3,sub2);
Node sub23=t.add("sub2sub3","Sub Item 2/3",3,sub2);
t.add("sub2sub4","Sub Item 2/4",3,sub2);
t.add("sub2sub5","Sub Item 2/5",3,sub2);
t.add("sub2sub6","Sub Item 2/6",3,sub2);
t.add("sub2sub7","Sub Item 2/7",3,sub2);

t.add("sub3sub1","Sub Item 3/1",3,sub3);
t.add("sub3sub2","Sub Item 3/2",3,sub3);
Node sub33=t.add("sub3sub3","Sub Item 3/3",3,sub3);
t.add("sub3sub4","Sub Item 3/4",3,sub3);
t.add("sub3sub5","Sub Item 3/5",3,sub3);

t.add("sub4sub1","Sub item 1/4",5,sub4);
Node sub331 = t.add("sub3sub3sub1","Sub item 1/3/3",3,sub33);
Node sub3311 = t.add("sub3sub3sub1sub1","Sub item 1/1/3/3",3,sub331);
t.add("sub2sub3sub1","Sub Item 1/3/2",7,sub23);
t.add("sub2sub3sub2","Sub Item 2/3/2",7,sub23);
t.add("sub2sub3sub3","Sub Item 3/3/2",7,sub23);
t.add("sub2sub3sub4","Sub Item 4/3/2",7,sub23);
//t.add("ff","fffffff",10,"dwdw");
t.delete("sub5");
//t.delete("sub2");
print(t,null,0);
System.out.println("------------------------------------------------");
System.out.println("Tree Node count is:"+t.count());
System.out.println("Tree deep is:"+t.getMaxDeep());
System.out.println("Tree max values is:"+t.getMaxValues());
System.out.println("-----------Tail nodes-------------------------------------");
java.util.Enumeration e=t.getTailNodes();
while(e.hasMoreElements()){
Node n=(Node)e.nextElement();
System.out.print(" "+n.getId());
}
System.out.println();
System.out.println("-----------Sub tree sub3-------------------------------------");
Tree nt=t.getSubTree(sub3);
print(nt,null,0);
System.out.println("-----------Sub tree sub2-------------------------------------");
Tree nt2=t.getSubTree(sub2);
print(nt2,null,0);
System.out.println("-----------all nodes-------------------------------------");
java.util.Enumeration e2=t.getNodes();
while(e2.hasMoreElements()){
Node n=(Node)e2.nextElement();
if(t.isTailNode(n)){
System.out.println("Node "+n.getId()+" is tail node.");
}else
System.out.println("Node "+n.getId()+" is not tail node.");
}
}