java代码实现决策树 编程实现决策树

如何用Java实现树形结构啊？

package tree;

我们提供的服务有：网站设计、成都网站制作、微信公众号开发、网站优化、网站认证、宜州ssl等。为1000+企事业单位解决了网站和推广的问题。提供周到的售前咨询和贴心的售后服务，是有科学管理、有技术的宜州网站制作公司

import java.util.LinkedList;

import java.util.List;

/**

* 功能：把一个数组的值存入二叉树中，然后进行3种方式的遍历

*

* 参考资料0:数据结构(C语言版)严蔚敏

*

* 参考资料1：

*

* 参考资料2：

*

* @author ocaicai@yeah.net @date: 2011-5-17

*

*/

public class BinTreeTraverse2 {

private int[] array = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };

private static ListNode nodeList = null;

/**

* 内部类：节点

*

* @author ocaicai@yeah.net @date: 2011-5-17

*

*/

private static class Node {

Node leftChild;

Node rightChild;

int data;

Node(int newData) {

leftChild = null;

rightChild = null;

data = newData;

}

}

public void createBinTree() {

nodeList = new LinkedListNode();

// 将一个数组的值依次转换为Node节点

for (int nodeIndex = 0; nodeIndex array.length; nodeIndex++) {

nodeList.add(new Node(array[nodeIndex]));

}

// 对前lastParentIndex-1个父节点按照父节点与孩子节点的数字关系建立二叉树

for (int parentIndex = 0; parentIndex array.length / 2 - 1; parentIndex++) {

// 左孩子

nodeList.get(parentIndex).leftChild = nodeList

.get(parentIndex * 2 + 1);

// 右孩子

nodeList.get(parentIndex).rightChild = nodeList

.get(parentIndex * 2 + 2);

}

// 最后一个父节点:因为最后一个父节点可能没有右孩子，所以单独拿出来处理

int lastParentIndex = array.length / 2 - 1;

// 左孩子

nodeList.get(lastParentIndex).leftChild = nodeList

.get(lastParentIndex * 2 + 1);

// 右孩子,如果数组的长度为奇数才建立右孩子

if (array.length % 2 == 1) {

nodeList.get(lastParentIndex).rightChild = nodeList

.get(lastParentIndex * 2 + 2);

}

}

/**

* 先序遍历

*

* 这三种不同的遍历结构都是一样的，只是先后顺序不一样而已

*

* @param node

* 遍历的节点

*/

public static void preOrderTraverse(Node node) {

if (node == null)

return;

System.out.print(node.data + " ");

preOrderTraverse(node.leftChild);

preOrderTraverse(node.rightChild);

}

/**

* 中序遍历

*

* 这三种不同的遍历结构都是一样的，只是先后顺序不一样而已

*

* @param node

* 遍历的节点

*/

public static void inOrderTraverse(Node node) {

if (node == null)

return;

inOrderTraverse(node.leftChild);

System.out.print(node.data + " ");

inOrderTraverse(node.rightChild);

}

/**

* 后序遍历

*

* 这三种不同的遍历结构都是一样的，只是先后顺序不一样而已

*

* @param node

* 遍历的节点

*/

public static void postOrderTraverse(Node node) {

if (node == null)

return;

postOrderTraverse(node.leftChild);

postOrderTraverse(node.rightChild);

System.out.print(node.data + " ");

}

public static void main(String[] args) {

BinTreeTraverse2 binTree = new BinTreeTraverse2();

binTree.createBinTree();

// nodeList中第0个索引处的值即为根节点

Node root = nodeList.get(0);

System.out.println("先序遍历：");

preOrderTraverse(root);

System.out.println();

System.out.println("中序遍历：");

inOrderTraverse(root);

System.out.println();

System.out.println("后序遍历：");

postOrderTraverse(root);

}

}

简单的JAVA多叉树问题实现

TreeNode.java

/*

* Copyright Walker Studio

* All Rights Reserved.

* 

* 文件名称： TreeNode.java

* 摘 要：

* 作 者： Walker

* 创建时间： 2013-03-19

*/

package com.walker.commons.data.model;

/**

* 树节点

* 

* @author Walker

* @version 1.0.0.0

*/

public class TreeNode 

{

/** 节点Id*/

private String nodeId;

/** 父节点Id*/

private String parentId;

/** 文本内容*/

private String text;

/**

 * 构造函数

 * 

 * @param nodeId 节点Id

 */

public TreeNode(String nodeId)

{

this.nodeId = nodeId;

}

/**

 * 构造函数

 * 

 * @param nodeId 节点Id

 * @param parentId 父节点Id

 */

public TreeNode(String nodeId, String parentId)

{

this.nodeId = nodeId;

this.parentId = parentId;

}

public String getNodeId() {

return nodeId;

}

public void setNodeId(String nodeId) {

this.nodeId = nodeId;

}

public String getParentId() {

return parentId;

}

public void setParentId(String parentId) {

this.parentId = parentId;

}

public String getText() {

return text;

}

public void setText(String text) {

this.text = text;

}

}

ManyTreeNode.java

/*

* Copyright Walker Studio

* All Rights Reserved.

* 

* 文件名称： ManyTreeNode.java

* 摘 要：

* 作 者： Walker

* 创建时间： 2013-03-19

*/

package com.walker.commons.data.model;

import java.util.ArrayList;

import java.util.List;

/**

* 多叉树节点

*

* @author Walker

* @verion 1.0.0.0

*/

public class ManyTreeNode 

{

/** 树节点*/

private TreeNode data;

/** 子树集合*/

private ListManyTreeNode childList;

/**

 * 构造函数

 * 

 * @param data 树节点

 */

public ManyTreeNode(TreeNode data)

{

this.data = data;

this.childList = new ArrayListManyTreeNode();

}

/**

 * 构造函数

 * 

 * @param data 树节点

 * @param childList 子树集合

 */

public ManyTreeNode(TreeNode data, ListManyTreeNode childList)

{

this.data = data;

this.childList = childList;

}

public TreeNode getData() {

return data;

}

public void setData(TreeNode data) {

this.data = data;

}

public ListManyTreeNode getChildList() {

return childList;

}

public void setChildList(ListManyTreeNode childList) {

this.childList = childList;

}

}

ManyNodeTree.java

/*

* Copyright Walker Studio

* All Rights Reserved.

* 

* 文件名称： ManyNodeTree.java

* 摘 要：

* 作 者： Walker

* 创建时间： 2013-03-19

*/

package com.walker.commons.data.model;

import java.util.ArrayList;

import java.util.List;

/**

* 多叉树生成、遍历工具

* 

* @author Walker

* @version 1.0.0.0

*/

public class ManyNodeTree 

{

/** 树根*/

private ManyTreeNode root;

/**

 * 构造函数

 */

public ManyNodeTree()

{

root = new ManyTreeNode(new TreeNode("root"));

}

/**

 * 生成一颗多叉树，根节点为root

 * 

 * @param treeNodes 生成多叉树的节点集合

 * @return ManyNodeTree

 */

public ManyNodeTree createTree(ListTreeNode treeNodes)

{

if(treeNodes == null || treeNodes.size()  0)

return null;

ManyNodeTree manyNodeTree =  new ManyNodeTree();

//将所有节点添加到多叉树中

for(TreeNode treeNode : treeNodes)

{

if(treeNode.getParentId().equals("root"))

{

//向根添加一个节点

manyNodeTree.getRoot().getChildList().add(new ManyTreeNode(treeNode));

}

else

{

addChild(manyNodeTree.getRoot(), treeNode);

}

}

return manyNodeTree;

}

/**

 * 向指定多叉树节点添加子节点

 * 

 * @param manyTreeNode 多叉树节点

 * @param child 节点

 */

public void addChild(ManyTreeNode manyTreeNode, TreeNode child)

{

for(ManyTreeNode item : manyTreeNode.getChildList())

{

if(item.getData().getNodeId().equals(child.getParentId()))

{

//找到对应的父亲

item.getChildList().add(new ManyTreeNode(child));

break;

}

else

{

if(item.getChildList() != null  item.getChildList().size()  0)

{

addChild(item, child);

}

}

}

}

/**

 * 遍历多叉树 

 * 

 * @param manyTreeNode 多叉树节点

 * @return 

 */

public String iteratorTree(ManyTreeNode manyTreeNode)

{

StringBuilder buffer = new StringBuilder();

buffer.append("\n");

if(manyTreeNode != null) 

{

for (ManyTreeNode index : manyTreeNode.getChildList()) 

{

buffer.append(index.getData().getNodeId()+ ",");

if (index.getChildList() != null  index.getChildList().size()  0 ) 

{

buffer.append(iteratorTree(index));

}

}

}

buffer.append("\n");

return buffer.toString();

}

public ManyTreeNode getRoot() {

return root;

}

public void setRoot(ManyTreeNode root) {

this.root = root;

}

public static void main(String[] args)

{

ListTreeNode treeNodes = new ArrayListTreeNode();

treeNodes.add(new TreeNode("系统权限管理", "root"));

treeNodes.add(new TreeNode("用户管理", "系统权限管理"));

treeNodes.add(new TreeNode("角色管理", "系统权限管理"));

treeNodes.add(new TreeNode("组管理", "系统权限管理"));

treeNodes.add(new TreeNode("用户菜单管理", "系统权限管理"));

treeNodes.add(new TreeNode("角色菜单管理", "系统权限管理"));

treeNodes.add(new TreeNode("用户权限管理", "系统权限管理"));

treeNodes.add(new TreeNode("站内信", "root"));

treeNodes.add(new TreeNode("写信", "站内信"));

treeNodes.add(new TreeNode("收信", "站内信"));

treeNodes.add(new TreeNode("草稿", "站内信"));

ManyNodeTree tree = new ManyNodeTree();

System.out.println(tree.iteratorTree(tree.createTree(treeNodes).getRoot()));

}

}

用Java实现一个树形结构，并对其进行遍历

import java.util.Iterator;

import java.util.Random;

import java.util.TreeSet;

public class Demo{

public static void main(String[] args) throws Exception {

TreeSetInteger ts = new TreeSetInteger();

for(int i = 0; i  10; i++){

ts.add(new Random().nextInt(999));

}

for(IteratorInteger it = ts.iterator(); it.hasNext();){

System.out.println(it.next());

}

}

}

//上面是利用TreeSet进行简单的二叉树实现，另有遍历，当然遍历是自然顺序。

//如有需要请自行修改吧。

如何使用Java Weka开源项目，实现J48决策树、支持向量机算法，在10个UCI数据集上对这两个算法进行性能？

public static void Regular() throws Exception {

File inputfile = new File("F:\\weka\\eucalyptus_Train.arff");

ArffLoader loader = new ArffLoader();

loader.setFile(inputfile);

Instances insTrain = loader.getDataSet();

insTrain.setClassIndex(insTrain.numAttributes()-1);

inputfile = new File("F:\\weka\\eucalyptus_Test.arff");

loader.setFile(inputfile);

Instances insTest = loader.getDataSet();

insTest.setClassIndex(insTest.numAttributes()-1);

double sum = insTest.numInstances();

int right = 0;

Classifier clas = new J48();

//Classifier clas = new weka.classifiers.bayes.BayesNet();

clas.buildClassifier(insTrain);

for(int i = 0; i  sum; i++) {

if(clas.classifyInstance(insTest.instance(i)) == insTest.instance(i).classValue()) {

right++;

}

System.out.println(clas.classifyInstance(insTest.instance(i))+" :　"+insTest.instance(i).classValue());

}

System.out.println("分类准确率："+right/sum);

}

svm的话，要用一个wlsvm的包。 代码是一样的，就是Classifier class= new J48()这里要用svm的实例