Java two-fork tree sorting and traversing file display text Format file Tree _java

java Two-fork tree sorting algorithm
The description of the sorted binary tree is also a recursive description, so the construction of the sorted binary tree is naturally recursive:
Sort the 3 characteristics of the binary tree:
1: The value of all the left children of the current node is less than the current node's value;
2: All the right children of the current node are greater than the current node's value;
3: The child node also satisfies two points

Package test.sort; public class Binarynode {private int value;//current value private binarynode lchild;//left child private Binarynod 
  E 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. 
* 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 Traversal file display text format of the file tree
in Java to write a code calendar tree, print out the structure, similar to the command in the CMD to enter the results. The
was simple enough to know that it was a little hard to do. If you are interested, you can also try.

Package Test.io; On the internet to find, heard or old bamboo original words.
Code concise, but I did a good job to digest 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). t
   Ostring (lftstr + "│", "├-"));
  } b.append (lftstr+ children.get (Children.size ()-1). toString (Lftstr + "", "└-")); Return b.toString ();
  public static void Main (string[] args {folder root = new Folder ("menu list");
  Folder F1 = new Folder ("Start Menu");
  Root.addchild (F1);
  Folder F1_1 = new Folder ("program");
  F1.addchild (f1_1);
  Folder F1_1_1 = new folder ("Attachment");
  F1_1.addchild (f1_1_1);
  Folder F1_1_1_1 = new Folder ("Entertainment");
  F1_1_1.addchild (f1_1_1_1);
  Folder F1_1_1_2 = new Folder ("Entertainment 2");
  F1_1_1.addchild (f1_1_1_2);
  Folder F1_2 = new Folder ("Auxiliary tool");
  F1.addchild (f1_2);
 System.out.println (Root.tostring ("", "$")); }//**************************************//After digestion I modified. 
printable file structure 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 ();
}//*****************************************//Then I still find it inconvenient to understand, after a few days may forget,//or write their own, although the idea of copying, but I feel that their understanding is very convenient.
With annotations, import java.io.*;
 public class Tree {File root = null;
 Public tree (File f) {this.root = f; /** test├1│├ Directory 1.txt│├ directory 11││├111.txt││└112.txt│└12└test.pdf//** * @param root file that is currently being scanned * @pa Ram CHILDLEFTSTR If the file has children, Childleftstr * Indicates the structural information that should be printed on the left side of the child's node * Take the example above, the child's left of the root node test is "empty, node" directory 11 "of the child's Structure information is "││", * @param junction node icon, if the node is the last node of its father, * thenFor "└", otherwise "├". */public void Showtree (File root, String childleftstr, String junction) {//Print node information System.out.println (junction + R
  Oot.getname ());
   If there are children, and the number of children is not 0 if (!root.isfile () &&root.listfiles (). length!=0) {file[] files = root.listfiles ();
   Construct child node tree[] children = new Tree[files.length];
   for (int i=0; i<files.length; i++) {Children[i] = new Tree (files[i)); //Print child node for (int i=0; i<children.length-1; i++) {//To all child nodes, first print out the left structure information, System.out.print (CHILDLEFTSTR)
    ;
    Recursive call Showtree, note that the parameter changes, the file added depth of time, its children's structure information will also//increase, if not the last child, the structure of information to be added "│."
   Showtree (children[i].root,childleftstr+ "│", "├");
   //Last child needs special handling//print structure information System.out.print (CHILDLEFTSTR);
   If this is the last child, the structure information should be added "".
  The knot shape is also adjusted to "└" 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, "", ""); }
}