怎样把树储存在内存里

[starc]

如题
求储存算法

[kokobox]

没太明白lz的意思

直接用cache存

[jokerdx]

帮顶~~~~~~~~~~~

[iamklaus]

不建议LZ将整颗树存入内存中,如果小一些还好,要是数据量大一些的话可就够你喝一壶的了.
通常的缓存可以通过cache来实现.

[starc]

[Quote=引用 8 楼 iamklaus 的回复:]

不建议LZ将整颗树存入内存中,如果小一些还好,要是数据量大一些的话可就够你喝一壶的了.
通常的缓存可以通过cache来实现.
[/Quote]有一棵树结构如下

root
|_child1
|_child2
|_child21
.
.~~~~
|~~~~
|_child2..
|_childxx
|_childxx..
通过cache如何实现呢

[专业二三维GIS]

存一些递归嵌套的对象.

[Yedy2000]

树是由节点组成，给个节点类

class Note {
	private Object element;
	private List<Note> childList;

	public Note(Object element, List<Note> childList) {
		this.element = element;
		this.childList = childList;
	}
	
	public Object getElement(){
		return element;
	}
	public List<Note> getChildList(){
		return childList;
	}
}

[xsm]

  import   java.io.*;     
  import   java.util.Stack;     
      
  public   class   myTest   {     
  private   myTree   tree;     
      
      
  /**    
  *二叉树的插入，参数为（关键字，数据）    
  *    
  **/     
  public   void   insert(int   key,   int   data)     
  {     
  if(tree   ==   null)     
  {     
  tree   =   new   myTree();     
  tree.key   =   key;     
  tree.data   =   data;     
  }     
  else     
  {     
  myTree   newTree   =   new   myTree();     
  newTree.key   =   key;     
  newTree.data   =   data;     
  myTree   parent   =   tree;     
  while(true)     
  {     
  if(   newTree.key   <   parent.key)     
  {     
  if(   parent.leftChild   ==   null)     
  {     
  parent.leftChild   =   newTree;     
  return;     
  }     
  else     
  {     
  parent   =   parent.leftChild;     
  }     
  }     
  else   if(   newTree.key   >   parent.key)     
  {     
  if(parent.rightChild   ==   null)     
  {     
  parent.rightChild   =   newTree;     
  return;     
  }     
  else     
  {     
  parent   =   parent.rightChild;     
  }     
  }     
  }     
      
  }     
  }     
      
  /**    
    *   二叉树的查找，参数为（关键字），返回值为   myTree的一个实例    
    *      
    *   **/     
  public   myTree   find(int   key)     
  {     
  if(   tree   ==   null   )   return   null;     
  myTree   curr   =   new   myTree();     
  curr.key   =   key;     
  myTree   parent   =   tree;     
  while(true)     
  {     
  if(   parent   ==   null)     
  {     
  return   null;     
  }     
  else   if(   curr.key   ==   parent.key)     
  {     
  return   parent;     
  }     
  else   if(   curr.key   >   parent.key)     
  {     
  parent   =   parent.rightChild;     
  }     
  else   if(   curr.key   <   parent.key)     
  {     
  parent   =   parent.leftChild;     
  }     
  }     
  }     
      
      
      
  /*    
    *      
    *   递归的二叉树中序遍历    
    *      
    *      
    */     
  private   static   void   midOrder(myTree   tree)     
  {     
  if(tree   !=   null   )     
  {     
  midOrder(tree.leftChild);     
  System.out.println(tree+","+tree.key+","+tree.data);     
  midOrder(tree.rightChild);     
  }     
  }     
      
                        
  /*    
    *   前序遍历      
    */     
  private   static   void   frontOrder(myTree   tree)     
  {     
  if(tree   !=   null)     
  {     
  System.out.println(""+tree.key+"   ,   "+tree.data);     
  frontOrder(tree.leftChild);     
  frontOrder(tree.rightChild);     
  }     
  }     
      
      
  public   static   void   main(String[]   args)       
  {     
  System.out.println("Tree   view   Begin");     
  myTest   t1   =   new   myTest();     
  t1.insert(8,25);     
  t1.insert(5,9);     
  t1.insert(58,87);     
  t1.insert(13,82);     
  t1.insert(4,8);     
  t1.insert(12,54);     
  t1.insert(53,123);     
  t1.insert(56,47);     
  t1.insert(2,75);     
  t1.insert(34,5);     
  t1.insert(6,23);     
  System.out.println("现在开始遍历:");     
  midOrder2(t1.tree);     
  midOrder(t1.tree);     
  }     
  }  

java二叉树算法，实现添加数据形成二叉树功能，并以先序的方式打印出来.

[starc]

这种算法有没有什么专业术语啊，像是递归呢

[Yedy2000]

我也没明白。

[starc]

[Quote=引用 1 楼 kokobox 的回复:]
没太明白lz的意思

直接用cache存
[/Quote]有一棵树结构如下

root
|_child1
|_child2
|_child21
.
.~~~~
|~~~~
|_child2..
|_childxx
|_childxx..
从数据库里查询出childxx并迭代出如上所示的树，怎么才能在内存里把它表示出

来呢
求此树在内存里的存储算法