在MapReduce下实现的id3算法

最新推荐文章于 2021-02-22 20:57:34 发布
最新推荐文章于 2021-02-22 20:57:34 发布
阅读量802 收藏 8
点赞数
分类专栏： hadoop linux 文章标签： id3 MapReduc
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_33016527/article/details/82731798
版权

(需实现装好hadoop分布式环境配好jdk，安装eclipse linux版 

数据源source.txt

  • 青绿,蜷缩,浊响,清晰,凹陷,硬滑,是
乌黑,蜷缩,沉闷,清晰,凹陷,硬滑,是
乌黑,蜷缩,浊响,清晰,凹陷,硬滑,是
青绿,蜷缩,沉闷,清晰,凹陷,硬滑,是
浅白,蜷缩,浊响,清晰,凹陷,硬滑,是
青绿,稍蜷,浊响,清晰,稍凹,软粘,是
乌黑,稍蜷,浊响,稍糊,稍凹,软粘,是
乌黑,稍蜷,浊响,清晰,稍凹,硬滑,是
乌黑,稍蜷,沉闷,稍糊,稍凹,硬滑,否
青绿,硬挺,清脆,清晰,平坦,软粘,否
浅白,硬挺,清脆,模糊,平坦,硬滑,否
浅白,蜷缩,浊响,模糊,平坦,软粘,否
青绿,稍蜷,浊响,稍糊,凹陷,硬滑,否
浅白,稍蜷,沉闷,稍糊,凹陷,硬滑,否
乌黑,稍蜷,浊响,清晰,稍凹,软粘,否
浅白,蜷缩,浊响,模糊,平坦,硬滑,否
青绿,蜷缩,沉闷,稍糊,稍凹,硬滑,否

     

 将数据源上传到hdfs上

hdfs dfs -mkdir /id3
hdfs dfs -mkdir /id3/source
hdfs dfs -put source.txt /id3/source/

 用于去重统计各自变因素各属性在对应决策下出现的次数

CountData.java------------------------------第一个MapReduce的过程

import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.StringTokenizer;

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.DoubleWritable;
import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.Text;

import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.Mapper;
import org.apache.hadoop.mapreduce.Reducer;
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
import org.apache.hadoop.mapreduce.lib.input.TextInputFormat;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;
import org.apache.hadoop.mapreduce.lib.output.TextOutputFormat;

public class CountData {
	private String[] path;
	private static List<String> already;

	public CountData(String[] path, List<String> already) {
		this.path = path;
		CountData.already = already;
	}

	public static class EntropyMapper extends Mapper<Object, Text, Text, IntWritable> {
		public void map(Object key, Text value, Context context) throws IOException, InterruptedException {
			IntWritable one = new IntWritable(1);
			StringTokenizer sto = new StringTokenizer(value.toString());
			String[] rowtitle = { "1", "2", "3", "4", "5", "6", "7" };
			while (sto.hasMoreTokens()) {

				String[] rowditails = sto.nextToken("\n").split(",");
				List<String> rowlist = Arrays.asList(rowditails);
				boolean b = true;
				for (int j = 0; j < already.size(); j++) {
					b = b && rowlist.contains(already.get(j));
				}
				if (b == true) {
					String keyString = rowditails[rowditails.length - 1];
					Text k = new Text(keyString);
					context.write(k, one);
					if (already.size() == 0) {
						for (int i = 0; i < rowditails.length - 1; i++) {

							String keyString1 = rowtitle[i] + "&" + rowditails[i] + "&"
									+ rowditails[rowditails.length - 1];
							Text k1 = new Text(keyString1);
							context.write(k1, one);
						}
					} else {
						for (int i = 0; i < rowditails.length - 1; i++) {

							if (already.contains(rowditails[i])) {
								System.out.println(rowditails[i]);
							}else {
							String keyString1 = rowtitle[i] + "&" + rowditails[i] + "&"
									+ rowditails[rowditails.length - 1];
							Text k1 = new Text(keyString1);
							context.write(k1, one);}
						}
					}

				}

			}
		}
	}

	public static class Entropyreducer extends Reducer<Text, IntWritable, Text, IntWritable> {
		private IntWritable result = new IntWritable();

		public void reduce(Text key, Iterable<IntWritable> values, Context context)
				throws IOException, InterruptedException {
			int sum = 0;
			for (IntWritable val : values) {
				sum += val.get();
			}
			result.set(sum);
			context.write(key, result);
		}

	}

//	public static void main(String[] args) throws IOException, ClassNotFoundException, InterruptedException {
//		Configuration conf = new Configuration();
//		conf.set("fs.defaultFS", "hdfs://127.0.0.1:9000");
//		conf.set("mapred.textoutputformat.separator", "&");
//		Job job = Job.getInstance(conf, "countdata");
//		job.setInputFormatClass(TextInputFormat.class);
//		FileInputFormat.setInputPaths(job, new Path("/id3/source/*"));
//		job.setJarByClass(CountData.class);
//		job.setMapperClass(EntropyMapper.class);
//		job.setMapOutputKeyClass(Text.class);
//		job.setMapOutputValueClass(IntWritable.class);
//
//		job.setReducerClass(Entropyreducer.class);
//
//		job.setOutputKeyClass(Text.class);
//		job.setOutputValueClass(IntWritable.class);
//		job.setOutputFormatClass(TextOutputFormat.class);
//		FileOutputFormat.setOutputPath(job, new Path("/id3/System_output2"));
//		job.waitForCompletion(true);
//	}

	public void domr() throws IOException, ClassNotFoundException, InterruptedException {
		Configuration conf = new Configuration();
		conf.set("fs.defaultFS", "hdfs://127.0.0.1:9000");
		conf.set("mapred.textoutputformat.separator", "&");
		Job job = Job.getInstance(conf, "countdata");
		job.setInputFormatClass(TextInputFormat.class);
		FileInputFormat.setInputPaths(job, new Path(path[0]));
		job.setJarByClass(CountData.class);
		job.setMapperClass(EntropyMapper.class);
		job.setMapOutputKeyClass(Text.class);
		job.setMapOutputValueClass(IntWritable.class);

		job.setReducerClass(Entropyreducer.class);

		job.setOutputKeyClass(Text.class);
		job.setOutputValueClass(IntWritable.class);
		job.setOutputFormatClass(TextOutputFormat.class);
		FileOutputFormat.setOutputPath(job, new Path(path[1]));
		job.waitForCompletion(true);
	}

}

第一趟结果

 hdfs dfs -cat /id3/system_output/*

1&乌黑&否&2
1&乌黑&是&4
1&浅白&否&4
1&浅白&是&1
1&青绿&否&3
1&青绿&是&3
2&硬挺&否&2
2&稍蜷&否&4
2&稍蜷&是&3
2&蜷缩&否&3
2&蜷缩&是&5
3&沉闷&否&3
3&沉闷&是&2
3&浊响&否&4
3&浊响&是&6
3&清脆&否&2
4&模糊&否&3
4&清晰&否&2
4&清晰&是&7
4&稍糊&否&4
4&稍糊&是&1
5&凹陷&否&2
5&凹陷&是&5
5&平坦&否&4
5&稍凹&否&3
5&稍凹&是&3
6&硬滑&否&6
6&硬滑&是&6
6&软粘&否&3
6&软粘&是&2
否&9
是&8

 

 //计算个各列（各自变因素）各属性信息熵

DataEntroy.java-------------------------------------------------第二个MapReduce的过程


import java.io.IOException;
import java.util.List;
import java.util.Set;
import java.util.StringTokenizer;

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.DoubleWritable;
import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.Mapper;
import org.apache.hadoop.mapreduce.Reducer;
import org.apache.hadoop.mapreduce.Reducer.Context;
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
import org.apache.hadoop.mapreduce.lib.input.TextInputFormat;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;
import org.apache.hadoop.mapreduce.lib.output.TextOutputFormat;

import com.wdx.test.CountData.EntropyMapper;
import com.wdx.test.CountData.Entropyreducer;

public class DataEntroy {
	public static class EntropyMapper extends Mapper<Object, Text, Text,Text> {
		public void map(Object key, Text value, Context context) throws IOException, InterruptedException {
			//IntWritable one = new IntWritable(1);
			StringTokenizer sto = new StringTokenizer(value.toString());
			//String[] rowtitle = {"1","2","3","4","5","6","7"};
			while (sto.hasMoreTokens()) {
				String[] rowditails = sto.nextToken("\n").split("&");
				String keyString;
				String valueString;
				if(rowditails.length==4) {
					keyString = rowditails[0]+"&"+rowditails[1];
					valueString = rowditails[2]+"&"+rowditails[3];
				}else {
					keyString = "system&";
					valueString = rowditails[0]+"&"+rowditails[1];
				}
					
				
				Text k = new Text(keyString);
				Text v = new Text(valueString);
				
				context.write(k, v);
			}
		}
	}

	public static class Entropyreducer extends Reducer<Text, Text, Text, Text> {
		//private DoubleWritable result = new DoubleWritable();

		public void reduce(Text key, Iterable<Text> values, Context context)
				throws IOException, InterruptedException {
			double sum = 0;
			int i=0;
			double[] val = new double[2];
			String[] type = new String[2];
			for (Text val1 : values) {
				type[i]=val1.toString().split("&")[0];
				sum += Integer.parseInt(val1.toString().split("&")[1]);
				val[i++]=Integer.parseInt(val1.toString().split("&")[1]);
			}
			if(val[1]!=0) {
				double n1 = (val[0]/sum);
				double n2 = (val[1]/sum);
				double r = -n1*Math.log(n1)/Math.log(2)-n2*Math.log(n2)/Math.log(2);
				Text  result = new Text(r+"&"+sum);
				context.write(key, result);
			}else {
				if(type[0].trim().equals("是")) {
					
					DoubleWritable result1 = new DoubleWritable(1);
					Text  result = new Text(result1+"&"+sum);
					context.write(key, result);
				}else {
					DoubleWritable result1 = new DoubleWritable(0);
					Text  result = new Text(result1+"&"+sum);
					context.write(key, result);
				}
				
			}
			
		}

	}

//	public static void main(String[] args) throws IOException, ClassNotFoundException, InterruptedException {
//		Configuration conf = new Configuration();
//		conf.set("fs.defaultFS", "hdfs://127.0.0.1:9000");
//		conf.set("mapred.textoutputformat.separator", "&");
//		Job job = Job.getInstance(conf, "countdata");
//		job.setInputFormatClass(TextInputFormat.class);
//		FileInputFormat.setInputPaths(job, new Path("/id3/System_output/*"));
//		job.setJarByClass(DataEntroy.class);
//		job.setMapperClass(EntropyMapper.class);
//		job.setMapOutputKeyClass(Text.class);
//		job.setMapOutputValueClass(Text.class);
//
//		job.setReducerClass(Entropyreducer.class);
//
//		job.setOutputKeyClass(Text.class);
//		job.setOutputValueClass(DoubleWritable.class);
//		job.setOutputFormatClass(TextOutputFormat.class);
//		FileOutputFormat.setOutputPath(job, new Path("/id3/SystemEntroy_output8"));
//		job.waitForCompletion(true);
//	}
	
	
	
	

}

第一趟结果

 hdfs dfs -cat /id3/system_output1/*

1&乌黑&0.9182958340544896&6.0
1&浅白&0.7219280948873623&5.0
1&青绿&1.0&6.0
2&硬挺&0.0&2.0
2&稍蜷&0.9852281360342516&7.0
2&蜷缩&0.954434002924965&8.0
3&沉闷&0.9709505944546688&5.0
3&浊响&0.9709505944546688&10.0
3&清脆&0.0&2.0
4&模糊&0.0&3.0
4&清晰&0.7642045065086203&9.0
4&稍糊&0.7219280948873623&5.0
5&凹陷&0.863120568566631&7.0
5&平坦&0.0&4.0
5&稍凹&1.0&6.0
6&硬滑&1.0&12.0
6&软粘&0.9709505944546688&5.0
system&&0.9975025463691153&17.0

 

//获取相对信息增益（各列信息熵）由于信息增益＝系统信息熵－自变因素信息熵；所以用自变因素信息熵最小的相对表示信息增益最大

 EntroyCreamnet.java------------------------------------------第三个MapReduce的过程



import java.io.IOException;
import java.util.StringTokenizer;

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.DoubleWritable;
import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.Mapper;
import org.apache.hadoop.mapreduce.Reducer;
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
import org.apache.hadoop.mapreduce.lib.input.TextInputFormat;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;
import org.apache.hadoop.mapreduce.lib.output.TextOutputFormat;


public class EntroyCreamnet {
	public static class EntropyMapper extends Mapper<Object, Text, Text,DoubleWritable> {
		public void map(Object key, Text value, Context context) throws IOException, InterruptedException {
			//IntWritable one = new IntWritable(1);
			StringTokenizer sto = new StringTokenizer(value.toString());
			//String[] rowtitle = {"1","2","3","4","5","6","7"};
			while (sto.hasMoreTokens()) {
				String[] rowditails = sto.nextToken("\n").split("&");
				if(!(rowditails[0].equals("system"))) {
					String keyString = rowditails[0];
					double valueString =Double.parseDouble(rowditails[2])*Double.parseDouble(rowditails[3]);
						
					
					Text k = new Text(keyString);
					DoubleWritable v = new DoubleWritable(valueString);
					
					context.write(k, v);
				}
				
			}
		}
	}

	public static class Entropyreducer extends Reducer<Text, DoubleWritable, Text, DoubleWritable> {
			private DoubleWritable result = new DoubleWritable();
		
		public void reduce(Text key, Iterable<DoubleWritable> values, Context context) throws IOException, InterruptedException {
			double sum = 0;
			for (DoubleWritable val : values) {
				sum += val.get();
			}
			result.set(sum);		
			context.write(key, result);		
		}
			
		}


//	public static void main(String[] args) throws IOException, ClassNotFoundException, InterruptedException {
//		Configuration conf = new Configuration();
//		conf.set("fs.defaultFS", "hdfs://127.0.0.1:9000");
//		conf.set("mapred.textoutputformat.separator", "&");
//		Job job = Job.getInstance(conf, "EntroyCreamnet");
//		job.setInputFormatClass(TextInputFormat.class);
//		FileInputFormat.setInputPaths(job, new Path("/id3/SystemEntroy_output8/*"));
//		job.setJarByClass(EntroyCreamnet.class);
//		job.setMapperClass(EntropyMapper.class);
//		job.setMapOutputKeyClass(Text.class);
//		job.setMapOutputValueClass(DoubleWritable.class);
//
//		job.setReducerClass(Entropyreducer.class);
//
//		job.setOutputKeyClass(Text.class);
//		job.setOutputValueClass(DoubleWritable.class);
//		job.setOutputFormatClass(TextOutputFormat.class);
//		FileOutputFormat.setOutputPath(job, new Path("/id3/Systemcreament_output1"));
//		job.waitForCompletion(true);
//	}
//	
	
	
	
}

第一趟结果

 hdfs dfs -cat /id3/system_output2/*
 

1&15.119415478763749
2&14.532068975639483
3&14.564258916820032
4&10.487481033014394
5&12.041843979966417
6&16.854752972273346

主要算法实现过程

ID3.java



import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.DoubleWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
import org.apache.hadoop.mapreduce.lib.input.TextInputFormat;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;
import org.apache.hadoop.mapreduce.lib.output.TextOutputFormat;

import com.wdx.test.DataEntroy.EntropyMapper;
import com.wdx.test.DataEntroy.Entropyreducer;

public class ID3 {
	public static GTree<String> tree = new GTree<>();// 一颗通用树
	public String[] title = {"1","2","3","4","5","6","7"};//自变因素列表
	public String[][]  a = {
			{"青绿","乌黑","浅白"},
			{"蜷缩","稍缩","硬挺"},
			{"浊响","沉闷","清脆"},
			{"清晰","稍糊","模糊"},
			{"凹陷","稍凹","平坦"},
			{"硬滑","软粘"}		
	};//自变因素属性矩阵

	//数据去重分类计数
	public static void countData(String[] path,List<String> already) throws IOException, ClassNotFoundException, InterruptedException {
		CountData  countData = new CountData(path,already);
		countData.domr();
	}
	
	//计算个各列各属性信息熵
	public static void dataEntroy(String[] path) throws IOException, ClassNotFoundException, InterruptedException {
		Configuration conf = new Configuration();
		conf.set("fs.defaultFS", "hdfs://127.0.0.1:9000");
		conf.set("mapred.textoutputformat.separator", "&");
		Job job = Job.getInstance(conf, "DataEntroy");
		job.setInputFormatClass(TextInputFormat.class);
		FileInputFormat.setInputPaths(job, new Path(path[0]));
		job.setJarByClass(DataEntroy.class);
		job.setMapperClass(DataEntroy.EntropyMapper.class);
		job.setMapOutputKeyClass(Text.class);
		job.setMapOutputValueClass(Text.class);

		job.setReducerClass(DataEntroy.Entropyreducer.class);

		job.setOutputKeyClass(Text.class);
		job.setOutputValueClass(Text.class);
		job.setOutputFormatClass(TextOutputFormat.class);
		FileOutputFormat.setOutputPath(job, new Path(path[1]));
		job.waitForCompletion(true);
	}
	//获取相对信息增益（各列信息熵）由于信息增益＝系统信息熵－自变因素信息熵；所以用自变因素信息熵最小的相对表示信息增益最大
	public static void entroyCreamnet(String[] path) throws IOException, ClassNotFoundException, InterruptedException {
		Configuration conf = new Configuration();
		conf.set("fs.defaultFS", "hdfs://127.0.0.1:9000");
		conf.set("mapred.textoutputformat.separator", "&");
		Job job = Job.getInstance(conf, "EntroyCreamnet");
		job.setInputFormatClass(TextInputFormat.class);
		FileInputFormat.setInputPaths(job, new Path(path[0]));
		job.setJarByClass(EntroyCreamnet.class);
		job.setMapperClass(EntroyCreamnet.EntropyMapper.class);
		job.setMapOutputKeyClass(Text.class);
		job.setMapOutputValueClass(DoubleWritable.class);

		job.setReducerClass(EntroyCreamnet.Entropyreducer.class);

		job.setOutputKeyClass(Text.class);
		job.setOutputValueClass(DoubleWritable.class);
		job.setOutputFormatClass(TextOutputFormat.class);
		FileOutputFormat.setOutputPath(job, new Path(path[1]));
		job.waitForCompletion(true);
	}
	
	
	
	
	
	
	// 构建树
	
	public TreeNode<String> makeTree(String[] path,String name,TreeNode root,List<String> already) throws ClassNotFoundException, IOException, InterruptedException {

		
		countData(path,already);
		String[] path1 = {path[1]+"/*","/id3/"+name+"_output1"};
		dataEntroy(path1);
		String[] path2= {path1[1]+"/*","/id3/"+name+"_output2"};
		entroyCreamnet(path2);
		Configuration conf = new Configuration();
		HdfsDAO hdao = new HdfsDAO(conf);
		String all = hdao.cat(path2[1]+"/part-r-00000");
		String[] lines = all.split("\n");
		//int index=0;
		// 找信息增益最大的自变因素
		String maxname="";
		double min=10000;
		for(int i=0;i<lines.length;i++) {
			String[] details = lines[i].split("&");
			if(min>Double.parseDouble(details[1].trim()) ){
				min = Double.parseDouble(details[1].trim());
				maxname = details[0];
				
			}
		
		}
		int index = Arrays.binarySearch(title, maxname);
		TreeNode node = new TreeNode(maxname,null);
//		tree.insert(null, node);
		if (root == null) {
			
			root = node;
			tree.insert(null, root);
		} else {
			

			tree.insert(root, node);
		}
		//获取该列自变因素属性列表
		String[] clomndetails= a[index];
		index=index+1;
		Double[] entroy = new Double[clomndetails.length];
		//读取ｏｕｔout1文件
		String t = hdao.cat(path1[1]+"/part-r-00000");
		String[] tdatils =  t.split("\n");
		//获取自变因素对应熵
		for(int i=0;i<tdatils.length;i++) {
			for(int j=0;j<clomndetails.length;j++) {
				if(tdatils[i].split("&")[0].equals(""+index)&&tdatils[i].split("&")[1].equals(clomndetails[j])) {
					entroy[j]=Double.parseDouble(tdatils[i].split("&")[2]);
				}
			}
		}
		for(int k=0;k<clomndetails.length;k++) {
			List newalready = new ArrayList<>(already);//记录已经确定的属性，
			if(entroy[k]==0) {
				TreeNode node1 = new TreeNode(clomndetails[k],null);
				tree.insert(node, node1);
				TreeNode n = new TreeNode("no",null);
				tree.insert(node1, n);
			}else if(entroy[k]==1) {
				TreeNode node1 = new TreeNode(clomndetails[k],null);
				tree.insert(node, node1);
				TreeNode n = new TreeNode("yes",null);
				tree.insert(node1, n);
			}else {
				newalready.add(clomndetails[k]);
				TreeNode n = new TreeNode(clomndetails[k],null);
				tree.insert(node, n);
				String[] newpath = {"/id3/source/*","/id3/"+clomndetails[k]+"_output"};
				makeTree(newpath,clomndetails[k],n,newalready);
			}
		}
		return root;

	}

	public static void main(String[] args) throws ClassNotFoundException, IOException, InterruptedException {
		ID3 id3 = new ID3();
		String[] path = {"/id3/source/*","/id3/system_output"};
		List<String> already = new ArrayList<>();
		TreeNode<String> treenode = id3.makeTree(path,"system",null,already);
		tree.Travelsal1(treenode, 1);
	}

}

 数据结构支持



import java.util.ArrayList;
import java.util.List;

//通用树的节点
public class TreeNode<T>{
	private Object value;//数据区
	private List<TreeNode<T>> childlist;//孩子节点指针集合
	public TreeNode(){	
		value = null;
		childlist = new ArrayList<>();
	}
	
	public TreeNode(Object value,List<TreeNode<T>> childList) {
		this.value = value;
		if(childList!=null) {
			this.childlist = childList;
		}else {
			this.childlist=new ArrayList<>();
		}
		
	}

	public Object getValue() {
		return value;
	}

	public void setValue(Object value) {
		this.value = value;
	}

	public List<TreeNode<T>> getChildlist() {
		return childlist;
	}

	public void setChildlist(List<TreeNode<T>> childlist) {
		this.childlist = childlist;
	}
	
	
}



public class GTree<T> {
	// 根节点
	public TreeNode<T> root = null;

	// 插入
	public boolean insert(TreeNode<T> parent, TreeNode<T> node) {
		if (root == null) {
			root = node;
			return true;
		} else {
			if (findOne(root, parent)) {

				// 留待考虑
				// TODO 这里会不会直接修改节点的list,待考虑
				return parent.getChildlist().add(node);
			}
		}
		return false;
	}

	/**
	 * 
	 * @param tRoot要参照的根节点
	 * @param one要查找的节点
	 * @return 是否存在这个节点
	 */
	public boolean findOne(TreeNode<T> tRoot, TreeNode<T> one) {
		boolean b = false;
		// 参照根结点为空，则该节点一定不存在
		if (tRoot == null) {
			return false;
		}
		//
		if (tRoot == one) {
			return true;
		}

		if (tRoot.getChildlist() != null) {
			int length = tRoot.getChildlist().size();
			for (int i = 0; i < length; i++) {
				TreeNode<T> node = tRoot.getChildlist().get(i);
				if (node == one) {
					return true;
				} else {
					if (node.getChildlist().size() != 0) {
						b = b || findOne(node, one);
					}
				}
			}
		} else {
			return false;
		}

		return b;
	}

	// 遍历
	/**
	 * 
	 * @param root
	 *            根节点
	 * @param l
	 *            层数
	 */
	public void Travelsal(TreeNode<String> root, int l) {
		int temp = l * 10;

		if (root != null) {
			if (l == 1) {
				System.out.printf("|--%-10s--", root.getValue().toString());
			}

			if (root.getChildlist() != null && root.getChildlist().size() != 0) {
				l++;
				int length = root.getChildlist().size();
				for (int i = 0; i < length; i++) {
					TreeNode<String> node = root.getChildlist().get(i);
					System.out.printf("|--%-10s--", node.getValue());

					Travelsal(node, l);

					System.out.print("\n");
					int temp1 = temp;
					temp = temp + (temp / 10) * 5;
					System.out.printf("%-" + temp + "s", " ");
					temp = temp1;

				}
			}
		}
	}

	public void Travelsal1(TreeNode<String> root, int l) {

		System.out.print("|");
		int length = l * 3;
		for (int i = 1; i < length + 1; i++) {
			System.out.print("-");
			if(i%3==0) {
				System.out.print("|");
			}
		}
		//System.out.print("|");
		System.out.println(root.getValue());
		int clength = root.getChildlist().size();
		for (int j = 0; j < clength; j++) {
			Travelsal1(root.getChildlist().get(j), l + 1);
		}
	}

}

最终结果

|---|4
|---|---|清晰
|---|---|---|3
|---|---|---|---|浊响
|---|---|---|---|---|1
|---|---|---|---|---|---|青绿
|---|---|---|---|---|---|---|yes
|---|---|---|---|---|---|乌黑
|---|---|---|---|---|---|---|6
|---|---|---|---|---|---|---|---|硬滑
|---|---|---|---|---|---|---|---|---|yes
|---|---|---|---|---|---|---|---|软粘
|---|---|---|---|---|---|---|---|---|no
|---|---|---|---|---|---|浅白
|---|---|---|---|---|---|---|yes
|---|---|---|---|沉闷
|---|---|---|---|---|yes
|---|---|---|---|清脆
|---|---|---|---|---|no
|---|---|稍糊
|---|---|---|6
|---|---|---|---|硬滑
|---|---|---|---|---|no
|---|---|---|---|软粘
|---|---|---|---|---|yes
|---|---|模糊
|---|---|---|no

在hdfs上生成的中间文件列表

hdfs dfs -ls /id3/

hadoop@ubuntu:~/id3$ hdfs dfs -ls /id3/
18/09/16 15:37:18 WARN util.NativeCodeLoader: Unable to load native-hadoop library for your platform... using builtin-java classes where applicable
Found 16 items
drwxr-xr-x   - hadoop supergroup          0 2018-09-16 14:53 /id3/source
drwxr-xr-x   - hadoop supergroup          0 2018-09-16 14:53 /id3/system_output
drwxr-xr-x   - hadoop supergroup          0 2018-09-16 14:53 /id3/system_output1
drwxr-xr-x   - hadoop supergroup          0 2018-09-16 14:53 /id3/system_output2
drwxr-xr-x   - hadoop supergroup          0 2018-09-16 14:53 /id3/乌黑_output
drwxr-xr-x   - hadoop supergroup          0 2018-09-16 14:53 /id3/乌黑_output1
drwxr-xr-x   - hadoop supergroup          0 2018-09-16 14:53 /id3/乌黑_output2
drwxr-xr-x   - hadoop supergroup          0 2018-09-16 14:53 /id3/浊响_output
drwxr-xr-x   - hadoop supergroup          0 2018-09-16 14:53 /id3/浊响_output1
drwxr-xr-x   - hadoop supergroup          0 2018-09-16 14:53 /id3/浊响_output2
drwxr-xr-x   - hadoop supergroup          0 2018-09-16 14:53 /id3/清晰_output
drwxr-xr-x   - hadoop supergroup          0 2018-09-16 14:53 /id3/清晰_output1
drwxr-xr-x   - hadoop supergroup          0 2018-09-16 14:53 /id3/清晰_output2
drwxr-xr-x   - hadoop supergroup          0 2018-09-16 14:53 /id3/稍糊_output
drwxr-xr-x   - hadoop supergroup          0 2018-09-16 14:53 /id3/稍糊_output1
drwxr-xr-x   - hadoop supergroup          0 2018-09-16 14:53 /id3/稍糊_output2
hadoop@ubuntu:~/id3$

 

 

时长河
关注
专栏目录
数据挖掘笔记-分类-决策树-MapReduce实现-1
PURSUE ONE PIECE
05-28 4929
看了一些mahout在处理决策树和随机森林的过程，大体过程是Job只有一个Mapper处理,在map方法里面做数据的转换收集工作，然后在cleanup方法里面去做决策树的创建过程。大体来说，mahout决策树的构建过程好像并没有结合分布式计算,因为我也并没有仔仔细细的去研读mahout里面的源码，所以可能是我没发现。最后生成的决策树并未保存在HDFS上面，后面有时间在考虑下吧。之前写的代码都是单机上跑的，发现现在很流行hadoop,所以又试着用hadoop mapreduce来处理下决策树的创建。
Hadoop_ID3:基于HadoopID3分类算法的分布式实现
06-05
Hadoop_ID3 使用 Hadoop 的 ID3 分类算法的分布式实现。 存储库有两个独立的项目。 ID3 汽车和 ID3 葡萄酒。 前者基于 Cars 数据集 [1]，而后者基于 Wines 数据集 [2]。 这两者之间的区别在于 Cars 包含分类属性，而 Wines 包含实值属性，因此需要对 ID3 进行离散化才能工作（使用二进制离散化）。 该实现执行十倍交叉验证。 输入和测试文件包含在每个子项目中。 这些项目已准备好导入 Eclipse。 使用了 Hadoop 1.2.1 [3]。 您可能需要在构建选项中包含 hadoop 包的 jar 库。 项目设置好后，按运行，结果（精度、召回率、f-测量）将打印在控制台中。 [1] [2] [3] Hadoop ID3 版权所有 (C) 2013 Nick Georgiadis
关于重写ID3 Algorithm Based On MapReduceV1/C++/Streaming的一些心得体会
weixin_30399055的博客
12-24 68
心血来潮，同时想用C++连连手。面对如火如荼的MP，一阵念头闪过，如果把一些ML领域的玩意整合到MP里面是不是很有意思 确实很有意思，可惜mahout来高深，我也看不懂。干脆自动动手丰衣足食，加上自己对JAVA一窍不通，于是写了streming C++版的ID3，数据源是来大神orisun的原始数据。 整个过程都是下班后一边带孩子一边撰写，总共历时2周多，写了两个版本： 1，shell+st...
决策树算法（ID3和C45）
05-01
决策树算法（ID3和C45），两个算法分开写的，包含有数据集。
决策树之ID3
YouthDance
07-18 688
决策树之ID3 一、决策树         1、优点：计算复杂度不高，输出结构易于理解，对中间的缺失不敏感，可以处理不                 相关特征数据。 2、缺点：可能产生过度的匹配问题。 3、使用数据类型：数值型和标称型。 二、创建决策树分支        1、创建分支的createBranch()伪代码如下所示：              检测数据集中的每
MapReduce实现单元最短路径算法.doc
05-06
《MapReduce实现单元最短路径算法》 MapReduce是一种分布式计算模型，常用于处理大数据集。在本文档中，我们探讨了如何利用MapReduce来解决图论中的单元最短路径问题。单元最短路径问题旨在寻找图中从一个源节点到...
基于MapReduce实现物品协同过滤算法（ItemCF）
04-18
本话题主要探讨如何利用MapReduce来实现物品协同过滤算法（Item-based Collaborative Filtering, 简称ItemCF），这是一种推荐系统中常用的算法。我们将深入理解ItemCF的原理，以及如何将其与MapReduce相结合。 **...
基于MapReduce实现物品协同过滤算法（ItemCF）.zip
03-13
在大规模数据集上，使用传统的单机算法会面临性能瓶颈，因此通过MapReduce进行分布式实现，可以有效解决这一问题。 在本项目“MapReduce_ItemCF-master”中，我们可能会看到以下结构： 1. 输入数据：包含用户对...
MapReduce实现二度好友推荐算法
10-22
在IT领域，尤其是在大数据处理和社交网络分析中，"MapReduce实现二度好友推荐算法"是一种常见的技术应用。MapReduce是Google提出的一种分布式计算模型，主要用于处理和生成大规模数据集。在这个场景下，我们利用...
用MapReduce实现KMeans算法
04-22
此时，结合MapReduce框架可以在分布式环境中高效地执行KMeans算法。以下将详细阐述如何用MapReduce实现KMeans算法以及涉及的关键步骤。 1. **数据预处理**： 在HDFS（Hadoop Distributed File System）上存储数据...
HADOOP分类算法
06-27
HADOOP分类算法还有Hadoop聚类算法，可以继续搜索
基于MapReduce实现决策树算法代码
benzyh的专栏
04-04 3339
首先，基于C45决策树算法实现对应的Mapper算子，相关的代码如下： public class MapClass extends MapReduceBase implements Mapper { private final static IntWritable one = new IntWritable(1); private Text attValue = new T
数据挖掘算法——ID3（决策树）
yijichangkong的专栏
08-07 6524
决策树算法：决策树是对数据进行分类，以此达到预测的目的。该决策树方法先根据训练集数据形成决策树，如果该树不能对所有对象给出正确的分类，那么选择一些例外加入到训练集数据中，重复该过程一直到形成正确的决策集。决策树代表着决策集的树形结构。决策树由决策结点、分支和叶子组成。决策树中最上面的结点为根结点，每个分支是一个新的决策结点，或者是树的叶子。每个决策结点代表一个问题或决策，通常 对应于待分类对象的属性
基于MapReduce的SimRank++算法研究与实现
杨旭东的专栏
04-30 6599
一、算法应用背景 计算广告学(Computational Advertising)是一门广告营销科学，以追求广告投放的收益最大化为目标，重点解决用户与广告匹配的相关性和广告的竞价模型问题，涉及到自然语言处理、数据挖掘以及竞价营销、创意设计等诸多学科的融合。计算广告是根据给定的用户和网页内容，通过计算得到与之最匹配的广告并进行精准定向投放的一种广告投放机制，其目的是为用户提供最易于接受的优
MapReduce 应用：TF-IDF 分布式实现
weixin_30902675的博客
06-24 379
概述 本文要说的 TF-IDF 分布式实现，运用了很多之前 MapReduce 的核心知识点。算是 MapReduce 的一个小应用吧。 版权说明 著作权归作者所有。 商业转载请联系作者获得授权，非商业转载请注明出处。 本文作者：Q-WHai 发表日期： 2016年6月24日 本文链接：http://blog.csdn.net/lemon_tree1213...
weka数据集举例之天气数据集weather.nominal.arff
dujuancao11的博客
02-22 4866
例子weather.nominal.arff @relation weather.symbolic @attribute outlook {sunny, overcast, rainy} @attribute temperature {hot, mild, cool} @attribute humidity {high, normal} @attribute windy {TRUE, FALSE} @attribute play {yes, no} @data sunny,hot,high,FALS
从 WordCount 到 MapReduce 计算模型
weixin_30558305的博客
05-10 155
概述 虽然现在都在说大内存时代，不过内存的发展怎么也跟不上数据的步伐吧。所以，我们就要想办法减小数据量。这里说的减小可不是真的减小数据量，而是让数据分散开来。分开存储、分开计算。这就是 MapReduce 分布式的核心。 版权说明 著作权归作者所有。 商业转载请联系作者获得授权，非商业转载请注明出处。 本文作者：Q-WHai 发表日期： 2016年5月10日...
决策树算法实例(基于ID3)
Time 的博客
04-23 2290
基于ID3的决策树算法，文中使用的sklearn的库，使用graphviz可以将决策树转换为pdf查看。 案例中用到的模拟数据如下：############################################################################RID age income student credit_rating class_buys_computer
mapreduce代码实现协同过滤算法
最新发布
06-25
在MapReduce框架下实现协同过滤的一个常见方法是基于用户或物品的相似度计算。 以下是简化的MapReduce协同过滤算法实现步骤： 1. **Map阶段**（mapper）： - 输入是用户-物品评分数据（如用户ID，物品ID，评分）...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

时长河

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值