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

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;

thistZGWvkH.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

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

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 children = new ArrayList();

public void addChild(Folder f) {

children.add(f);

}

public List getChildren() {

return children;

}

public void setChildren(List childretZGWvkHn) {

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[i] = new DocTree(files[i]);

}

for (int i=0; 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

children[i] = new Tree(files[i]);

}

//打印孩子结点

for(int i=0; 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,"", "");

}

}

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

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 children = new ArrayList();

public void addChild(Folder f) {

children.add(f);

}

public List getChildren() {

return children;

}

public void setChildren(List childretZGWvkHn) {

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[i] = new DocTree(files[i]);

}

for (int i=0; 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

children[i] = new Tree(files[i]);

}

//打印孩子结点

for(int i=0; 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,"", "");

}

}

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 children = new ArrayList();

public void addChild(Folder f) {

children.add(f);

}

public List getChildren() {

return children;

}

public void setChildren(List childretZGWvkHn) {

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[i] = new DocTree(files[i]);

}

for (int i=0; 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

children[i] = new Tree(files[i]);

}

//打印孩子结点

for(int i=0; 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,"", "");

}

}

docTrees[i] = new DocTree(files[i]);

}

for (int i=0; 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

children[i] = new Tree(files[i]);

}

//打印孩子结点

for(int i=0; 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,"", "");

}

}

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

children[i] = new Tree(files[i]);

}

//打印孩子结点

for(int i=0; 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,"", "");

}

}

children[i] = new Tree(files[i]);

}

//打印孩子结点

for(int i=0; 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,"", "");

}

}

//对所有的孩子结点，先打印出左边的结构信息，

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

}

}

版权声明：本文内容由网络用户投稿，版权归原作者所有，本站不拥有其著作权，亦不承担相应法律责任。如果您发现本站中有涉嫌抄袭或描述失实的内容，请联系我们jiasou666@gmail.com 处理，核实后本网站将在24小时内删除侵权内容。