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 樹形表的讀取，望大牛解答怎麼實現

大概有以下幾種做法：

1. parentId法，每條數據都有一個parentId，記錄父記錄ID，構建樹的話，如果數據量小，全部載入，然後內存里構建樹

2. parentId+parentIds法，每條數據有一個parentId和parentIds兩個欄位，構建構，查詢parentIds，載入數據，然後內存構建樹

3. 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());
}
}