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,"", "");
 }
}