Java的二叉树排序以及遍历文件展示文本格式的文件树

java二叉树排序算法
排序二叉树的描述也是一个递归的描述， 所以排序二叉树的构造自然也用递归的：
排序二叉树的3个特征：
1：当前node的所有左孩子的值都小于当前node的值；
2：当前node的所有右孩子的值都大于当前node的值；
3：孩子节点也满足以上两点

package test.sort; 
 
public class binarynode { 
 private int value;//current value 
 private binarynode lchild;//left child 
 private binarynode rchild;//right child 
  
 public binarynode(int value, binarynode l, binarynode r){ 
  this.value = value; 
  this.lchild = l; 
  this.rchild = r; 
 } 
  
 public binarynode getlchild() { 
  return lchild; 
 } 
 public void setlchild(binarynode child) { 
  lchild = child; 
 } 
 public binarynode getrchild() { 
  return rchild; 
 } 
 public void setrchild(binarynode child) { 
  rchild = child; 
 } 
 public int getvalue() { 
  return value; 
 } 
 public void setvalue(int value) { 
  this.value = value; 
 } 
  
 //iterate all node. 
 public static void iterate(binarynode root){ 
  if(root.lchild!=null){ 
   iterate(root.getlchild()); 
  } 
  system.out.print(root.getvalue() + " "); 
  if(root.rchild!=null){ 
   iterate(root.getrchild()); 
  } 
 } 
  
 /** 
  * add child to the current node to construct a tree. 
  * time: o( nlog(n) ) 
  * **/ 
 public void addchild(int n){ 
  if(n<value){ 
   if(lchild!=null){ 
    lchild.addchild(n); 
   } 
   else{ 
    lchild = new binarynode(n, null, null); 
   } 
  } 
  else{ 
   if(rchild!=null){ 
    rchild.addchild(n); 
   } 
   else{ 
    rchild = new binarynode(n, null, null); 
   } 
  } 
 } 
  
 //test case. 
 public static void main(string[] args){ 
  system.out.println(); 
  int[] arr = new int[]{23,54,1,65,9,3,100}; 
  binarynode root = new binarynode(arr[0], null, null); 
  for(int i=1; i<arr.length; i++){ 
   root.addchild(arr[i]); 
  } 
  binarynode.iterate(root); 
 } 
} 

java遍历文件展示文本格式的文件树
用java写一个代码变历文件树，打印出结构，类似在cmd输入命令tree的结果。
本来觉得很简单，做的时候才知道有点难。要是感兴趣， 你也可以试试。

package test.io;
//在网上找的，听说还是老字竹原创。代码简洁，但是我费了好大的功副消化
import java.util.arraylist;
import java.util.list;
public class folder {
 public folder(string title) {
  this.title = title;
 }
 private string title;
 private list<folder> children = new arraylist<folder>();
 public void addchild(folder f) {
  children.add(f);
 }
 public list<folder> getchildren() {
  return children;
 }
 public void setchildren(list<folder> children) {
  this.children = children;
 }
 public string gettitle() {
  return title;
 }
 public void settitle(string title) {
  this.title = title;
 }
 public string tostring(string lftstr, string append) {
  stringbuilder b = new stringbuilder();
  b.append(append + title);
  b.append("/n");
  if (children.size() > 0) {
   for (int i = 0; i < children.size() - 1; i++) {
    b.append(lftstr+ children.get(i).tostring(lftstr + "│ ", 
"├-"));
   }
   b.append(lftstr+ children.get(children.size() - 1).tostring(lftstr + 
" ","└-"));
  }
  return b.tostring();
 }
 public static void main(string[] args) {
  folder root = new folder("菜单列表");
  folder f1 = new folder("开始菜单");
  root.addchild(f1);
  folder f1_1 = new folder("程序");
  f1.addchild(f1_1);
  folder f1_1_1 = new folder("附件");
  f1_1.addchild(f1_1_1);
  folder f1_1_1_1 = new folder("娱乐");
  f1_1_1.addchild(f1_1_1_1);
  folder f1_1_1_2 = new folder("娱乐2");
  f1_1_1.addchild(f1_1_1_2);
  folder f1_2 = new folder("辅助工具");
  f1.addchild(f1_2);
  system.out.println(root.tostring(" ", "$"));
 }
}
//**************************************
//经过消化之后我修改的。可打印文件结构
import java.io.*; 
public class doctree { 
 file root = null; 
  
 public doctree(file f){ 
  this.root = f; 
 }
  
 public static void main(string[] args){ 
  file root = new file("c://test"); 
  doctree tree = new doctree(root); 
  system.out.println(tree.tostring(" ", "")); 
 } 
  
 public string tostring(string leftstr, string append){ 
  stringbuilder b = new stringbuilder(); 
  b.append(append + root.getname()); 
  b.append("/n");
  if(!root.isfile()&&root.listfiles().length!=0){ 
   file[] files = root.listfiles(); 
   doctree[] doctrees = new doctree[files.length]; 
   for(int i=0; i<doctrees.length; i++){ 
    doctrees[i] = new doctree(files[i]); 
   } 
   for (int i=0; i<files.length-1; i++){ 
    b.append(leftstr + doctrees[i].tostring(leftstr+"│", "├")); 
   } 
   b.append(leftstr + doctrees[doctrees.length-1].tostring(leftstr + " ", "└")); 
  } 
  return b.tostring(); 
 }
}
//*****************************************
//然后我还是觉得理解起来不方便， 过几天说不定就忘记了，
//还是自己写一个， 虽然思想照抄， 但我觉得自己的理解起来很方便。
//带注释，
import java.io.*;
public class tree {
 file root = null;
 public tree(file f){
  this.root = f;
 }
 /**
 test
 ├1
 │├目录1.txt
 │├目录11
 ││├111.txt
 ││└112.txt
 │└12
 └test.pdf
  */
 /**
  * @param root 当前正在被扫描的根文件
  * @param childleftstr 如果该文件有孩子，childleftstr
  *  表示孩子节点的左面应该打印出来的结构性信息
  *  拿上面的例子来说，根结点test的孩子的左面的
  *  结构信息为"" 空，结点"目录11"的孩子的结构信息为"││",
  * @param junction 结点图标，如果是该结点是它父亲的最后一个结点，
  *  则为"└",否则为"├".
  */
 
 public void showtree(file root, string childleftstr, string junction){
  //打印结点的信息
  system.out.println(junction + root.getname());
  //如果有孩子， 而且孩子的数目不为0
  if(!root.isfile()&&root.listfiles().length!=0){
   file[] files = root.listfiles();
   //构造孩子结点
   tree[] children = new tree[files.length];
   for(int i=0; i<files.length; i++){
    children[i] = new tree(files[i]);
   }
   //打印孩子结点
   for(int i=0; i<children.length-1; i++){
    //对所有的孩子结点，先打印出左边的结构信息，
    system.out.print(childleftstr);
    //递归调用showtree， 注意参数有所变化，文件加的深度增加的时候
，它的孩子的结构信息也会
    //增加，如果不是最后一个孩子，则结构信息需加上"│"。
    showtree(children[i].root,childleftstr+"│", "├");
   }
   //最后一个孩子需要特殊处理
   //打印结构信息
   system.out.print(childleftstr);
   //如果是最后一个孩子，则结构信息需加上" "。
   //结点形状也调整为"└"
   showtree(children[files.length-1].root, childleftstr+" ","└");
  }
 }
 public static void main(string[] args) {
  file f = new file("c://test");
  tree t = new tree(f);
  t.showtree(f,"", "");
 }
}