java构建树_java 构建二叉树

1. java构建二叉树算法

下面是你第一个问题的解法，是构建了树以后又把后序输出的程序。以前写的，可以把输出后序的部分删除，还有检验先序中序的输入是否合法的代码也可以不要。/*****TreeNode.java*********/public class TreeNode {
char elem;
TreeNode left;
TreeNode right;
}/*******PlantTree.java*********/import java.io.*;
public class PlantTree {
TreeNode root;
public static void main(String[] args) {
PlantTree seed=new PlantTree();
String preorder=null;
String inorder=null;
try {
BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
System.out.println("Please input the preorder");
preorder=br.readLine();
System.out.println("Please input the inorder");
inorder=br.readLine();
} catch (Exception e) {
// TODO: handle exception
}

if(preorder!=null&&seed.checkTree(preorder,inorder)) {

seed.root=new TreeNode();
seed.root.elem=preorder.charAt(0);
seed.makeTree(preorder,inorder,seed.root);
System.out.println("The tree has been planted,the postorder is:");
seed.printPostorder(seed.root);
}
}

void makeTree(String preorder,String inorder,TreeNode root) {
int i=inorder.lastIndexOf(root.elem);

if(i!=0) {//有左子树
String leftPre=preorder.substring(1, i+1);
String leftIn=inorder.substring(0,i);
TreeNode leftNode=new TreeNode();
leftNode.elem=leftPre.charAt(0);
root.left=leftNode;
makeTree(leftPre,leftIn,leftNode);
}
if(i!=inorder.length()-1) {//有右子树
String rightPre=preorder.substring(i+1,preorder.length());
String rightIn=inorder.substring(i+1,inorder.length());
TreeNode rightNode=new TreeNode();
rightNode.elem=rightPre.charAt(0);
root.right=rightNode;
makeTree(rightPre,rightIn,rightNode);
}

}
void printPostorder(TreeNode root) {
if(root.left!=null)
printPostorder(root.left);
if(root.right!=null)
printPostorder(root.right);
System.out.print(root.elem);

}
boolean checkTree(String a,String b) {
for(int i=0;i<a.length();i++) {
if(i!=a.lastIndexOf(a.charAt(i))) {
System.out.println("There are same element in the tree");
return false;
}
if(!b.contains(""+a.charAt(i))) {
System.out.println("Invalid input");
return false;
}

}
if(a.length()==b.length())
return true;
return false;
}
}

2. 如何在java构造函数中创建一棵树

importjava.util.Stack;//导入栈包

publicclassnewtree{
	privatenewtreelchild;//声明数据成员
	privatenewtreerchild;
	privatechardata;
	
	privatenewtreeroot;

	publicnewtree(newtreel,newtreer,chardata){//有参构造函数进行成员赋值
		lchild=l;
		rchild=r;
		this.data=data;
	}

	publicnewtree(){//无参构造函数创建树
		newtreef=newnewtree(null,null,'f');
		newtreeg=newnewtree(null,null,'g');
		newtreed=newnewtree(null,null,'d');
		newtreee=newnewtree(null,null,'e');
		newtreeb=newnewtree(d,e,'b');
		newtreec=newnewtree(f,g,'c');
		newtreea=newnewtree(b,c,'a');
		this.root=a;
	}

	publicvoidvisit(newtreep){/*输出数据*/
		System.out.print(p.data);//访问结点
	}

	@SuppressWarnings("unchecked")
	publicvoidInOrder(){/*输入数据*/
		newtreep=this.root;//你建了一棵树要把根节点赋值进去啊
		Stacks=newStack();
		while(p!=null||!s.isEmpty())/*处理数据：进行中序遍历*/
		{
			if(p!=null){
				s.push(p);
				p=p.lchild;
			}else{
				p=(newtree)s.pop();
				p.visit(p);//this指的是当前的类对象
				p=p.rchild;
			}
		}
	}

	publicstaticvoidmain(String[]args){
		//TODOAuto-generatedmethodstub
		newtreeh=newnewtree();//声明变量，变量赋值
		h.InOrder();
	}
}
//根据你的代码改了一个
importjava.util.Stack;//导入栈包
publicclassnewtree{
	publicTreecreateTree(){//无参构造函数创建树
		Treef=newTree(null,null,'f');
		Treeg=newTree(null,null,'g');
		Treed=newTree(null,null,'d');
		Treee=newTree(null,null,'e');
		Treeb=newTree(d,e,'b');
		Treec=newTree(f,g,'c');
		Treea=newTree(b,c,'a');
		returna;
	}

	publicvoidInOrder(Treep){/*输入数据*/
		Stack<Tree>s=newStack<Tree>();
		while(p!=null||!s.isEmpty()){/*处理数据：进行中序遍历*/
			if(p!=null){
				s.push(p);
				p=p.lchild;
			}else{
				p=s.pop();
				System.out.print(p.data);
				p=p.rchild;
			}
		}
	}

	publicvoidinOrder1(Treep){
		if(p==null)
			return;
		inOrder1(p.lchild);
		System.out.print(p.data);
		inOrder1(p.rchild);
	}

	publicstaticvoidmain(String[]args){
		newtreeh=newnewtree();//声明变量，变量赋值
		h.InOrder(h.createTree());
		System.out.println();
		h.inOrder1(h.createTree());
	}
}

classTree{
	Treelchild;//声明数据成员
	Treerchild;
	chardata;

	Tree(Treelchild,Treerchild,chardata){
		this.lchild=lchild;
		this.rchild=rchild;
		this.data=data;
	}
}

3. java 树形表的读取，望大牛解答怎么实现

大概有以下几种做法：

parentId法，每条数据都有一个parentId，记录父记录ID，构建树的话，如果数据量小，全部加载，然后内存里构建树
parentId+parentIds法，每条数据有一个parentId和parentIds两个字段，构建构，查询parentIds，加载数据，然后内存构建树
parentId + startId + endId法，创建一条记录，指定他的子，可以开始和结束的ID范围。

4. 如何用java实现二叉树的构建

树的构建方法

注意：

1. 父节点数组下标从0到 n/2 -1 ，但是遍历时要小于n/2-1，因为最后一个父节点可能没有右孩子，当n/2-1为奇数时才有右孩子，为偶数时只有左孩子。

2. 结点左孩子下标为2n+1，右孩子下标为2n+2。

5. 如何用java无限级树形结构的构建

这个可以采用一对多关联表结构来构建。

6. 用java TreeModel将xml构建成树实现动态添加删除节点的功能

修改后要触发事件 fire .....的。

7. java中如何建立一个java树，请详解

importjava.awt.*;
importjavax.swing.*;
classTreeDemoextendsJFrame
{
	publicTreeDemo()
	{
		setSize(400,300);
		setTitle("演示怎样使用JTree");
		show();
		JScrollPanejPanel=newJScrollPane();
		getContentPane().add(jPanel);
		JTreejtree=newJTree();
		jPanel.getViewport().add(jtree,null);
		validate();
		setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
	}
}
publicclassExample5_25
{
	publicstaticvoidmain(String[]args)
	{
		TreeDemoframe=newTreeDemo();
	}
}

其中JScrollPane是一个带滚动条的面板类。

将对象加入到带滚动条的面板类中，在将已建的数放入到其中。

就可建立一个系统默认的树结构。

8. java 构建二叉树

首先我想问为什么要用LinkedList 来建立二叉树呢? LinkedList 是线性表,
树是树形的, 似乎不太合适。

其实也可以用数组完成，而且效率更高.
关键是我觉得你这个输入本身就是一个二叉树啊，
String input = "ABCDE F G";
节点编号从0到8. 层次遍历的话:
对于节点i.
leftChild = input.charAt(2*i+1); //做子树
rightChild = input.charAt(2*i+2);//右子树

如果你要将带有节点信息的树存到LinkedList里面, 先建立一个节点类:
class Node{
public char cValue;
public Node leftChild;
public Node rightChild;
public Node(v){
this.cValue = v;
}
}

然后遍历input,建立各个节点对象.
LinkedList tree = new LinkedList();
for(int i=0;i< input.length;i++)
LinkedList.add(new Node(input.charAt(i)));

然后为各个节点设置左右子树:
for(int i=0;i<input.length;i++){
((Node)tree.get(i)).leftChild = (Node)tree.get(2*i+1);
((Node)tree.get(i)).rightChild = (Node)tree.get(2*i+2);

}

这样LinkedList 就存储了整个二叉树. 而第0个元素就是树根，思路大体是这样吧。

9. java中没有指针，怎么构建一个链表树

java中要用到链表结构的话有LinkedList、LinkedHashSet和LinkedHashMap等集合可供使用，这些集合的底层都是由链表实现的

10. 用java怎么构造一个二叉树

定义一个结点类：
public class Node {
private int value;
private Node leftNode;
private Node rightNode;

public Node getRightNode() {
return rightNode;
}
public void setRightNode(Node rightNode) {
this.rightNode = rightNode;
}
public int getValue() {
return value;
}
public void setValue(int value) {
this.value = value;
}
public Node getLeftNode() {
return leftNode;
}
public void setLeftNode(Node leftNode) {
this.leftNode = leftNode;
}

}

初始化结点树：
public void initNodeTree()
{
int nodeNumber;
HashMap<String, Integer> map = new HashMap<String, Integer>();
Node nodeTree = new Node();

Scanner reader = new Scanner(System.in);

nodeNumber = reader.nextInt();
for(int i = 0; i < nodeNumber; i++) {
int value = reader.nextInt();
String str = reader.next();
map.put(str, value);
}

if (map.containsKey("#")) {
int value = map.get("#");
nodeTree.setValue(value);
setChildNode(map, value, nodeTree);
}

preTraversal(nodeTree);
}

private void setChildNode(HashMap<String, Integer> map, int nodeValue, Node parentNode) {
int value = 0;
if (map.containsKey("L" + nodeValue)) {
value = map.get("L" + nodeValue);
Node leftNode = new Node();
leftNode.setValue(value);
parentNode.setLeftNode(leftNode);

setChildNode(map, value, leftNode);
}

if (map.containsKey("R" + nodeValue)) {
value = map.get("R" + nodeValue);
Node rightNode = new Node();
rightNode.setValue(value);
parentNode.setRightNode(rightNode);

setChildNode(map, value, rightNode);
}
}

前序遍历该结点树：
public void preTraversal(Node nodeTree) {
if (nodeTree != null) {
System.out.print(nodeTree.getValue() + "\t");
preTraversal(nodeTree.getLeftNode());
preTraversal(nodeTree.getRightNode());
}
}

导航:首页 > 编程语言 > java构建树

java构建树

与java构建树相关的资料