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

为一下会不会有这种情况？ID parentID
1   0
2   0
3   1
4   1
5   1
6   2
.   .
.   .
.   .

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

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

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

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取出来作为结束条件

以前回答类似的问题时写了一个，没测过，不知道是否可以，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) {}
  }
}

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

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

我也遇到过类似问题
库结构和你一样找出一个父节点下所以字节点的方法
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());
}
}

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;
    }
}

这是主方法和递归调用方法：
    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.");
        }
    }

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

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

调试易

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

解决方案 »