java+树+数据结构+递归的应用

为了解决报表中不同地市的数据统计问题

***********数据统计问题，记录下树的解决方案。
二叉树：二叉树的结构-有且最多有两个子节点—不符合全国地市代码的统计要求
树： 所以构造一个普通的树应该可以解决。
下面是自己写的实现方案，和测试方法
有什么不足之处，哪位大佬看到后可以指教一下

树节点

/*
 * 树节点
 */
public class Node {
	//数据项
	public Long data;
	public List<Node> nodes;
	
	/**
	 * 构造方法
	 * @param data
	 */
	public Node(Long data) {
		this.data = data;
	}
    /** 
     * 添加子树 
     * @param tree 子树 
     */  
    public void addNode(Node node) { 
    	if(nodes==null){
    		nodes=new ArrayList<>();
    		nodes.add(node);
    	}else{
    		nodes.add(node);  
    	}
    }  

树

/*
 * 树类
 */
public class Tree {
	//根节点
	public Node root;
	/**
	 * 为了满足业务需求初始化数的时候指定数的根节点
	 * 需要根据地市代码初始化不同的树
	 * @param root
	 */
	public Tree(Node root){
		this.root=root;
	}
	/**
	 * 删除节点
	 * @param value
	 */
	public void delte(long value) {
		
	}
   

往指定节点下添加节点

		/**
		 * 指定节点添加子节点
		 * 根节点加入子节点
		 * @param value
		 */
		public void insert(long value,long parent) {
			//封装节点
			Node newNode = new Node(value);
			Node par = new Node(parent);
			//查找指定父节点
			Node current=find(par,parent);
			//给指定父节点添加节点
			current.addNode(newNode);
		}
	

查询指定节点

		/**
		 * 递归查找指定节点
		 * 需要根据对象递归，所以参数为Node
		 * @param value
		 */
		public Node find(long value) {
			Node parent = new Node(value);
			Node curnet = find(parent, value);
			if(curnet!=null){
				System.out.println(curnet.data);
			}else{
				System.out.println("数据不存在。。。。。");
			}
			return curnet;
		}
		 /**
		 * 递归查找指定节点
		 * 需要根据对象递归，所以参数为Node
		 * @param value
		 */
		public Node find(Node parent,long value) {
			Node curnet= find(parent,true,value);
			return curnet;
		}
		 /**
		 * 递归查找指定节点
		 * 需要对树进行递归，所以参数为Node
		 * flag 判断是否是跟节点
		 * value 查找的值
		 * @param value
		 */
		public Node find(Node parent, boolean flag, long value) {
		// 引用当前节点，从根节点开始
		Node curnet = null;
		if (flag) {
			curnet = root;
			if (curnet.data != value) {
				// 如果value不是根节点那么查找是否是子节点
				List<Node> currents = curnet.nodes;
				if (currents != null && currents.size() > 0) {
					for (Node node : currents) {
						if (node.data != value) {
							// 如果在根节点的子节点中没有找到，那么去子节点中接着递归
							curnet=find(node, false, value);
							//下面的递归结束，或者找到数据，这里接着循环，
							//为了防止找到数据后，还接着递归所有这里做下校验
							if(curnet!=null&&curnet.data==value){
								return curnet;
							}
						} else {
							// 如果在根节点的子节点中找到返回改节点
							return curnet = node;
						}
					}
				} else {
					// 如果查找的是根节点，那么直接返回跟节点
					return curnet;
				}
			}
		}
		if (!flag) {
			// 下次递归不能再从跟节点开始,从根节点的子节点开始
				if (parent.nodes != null) {
					curnet = parent;
					// 比较查找值和当前节点的值不相等，若果存在子节点，那么接着递归子节点
					List<Node> currents = curnet.nodes;
					if (currents != null && currents.size() > 0) {
						for (Node node : currents) {
							if (node.data != value) {
								curnet=find(node, false, value);
							} else {
								// 找到直接返回
								return curnet = node;
							}
						}
					}
			}
		}
		return curnet;
	}

遍历指定节点的所有子节点

		/** 
	     * 查找指定节点的所有子节点
	     * @param root 根结点 
	     */  
	    public void preOrder(long value) {
	    	Node parent =new Node(value);
	    	preOrder(parent,true,value);
	    }
	/**
	 * 递归遍历指定节点的所有节点 
	 * 1、定位指定节点，需要 find 方法 
	 * 2、递归Node数，所以需要传入对象Node
	 * 
	 * @param root 根结点
	 */
	public void preOrder(Node parent, boolean flag, long value) {
		Node current = parent;
		if (flag) {
			// 从根节点查找到该节点
			current = find(value);
			System.out.println("查找的节点+++++++" + value + "+++++++");
			flag = false;
		}
		if (!flag) {
			// 如果当前节点有子节点，递归遍历该节点的所有子节点
			if (current.nodes != null) {
				for (Node child : current.nodes) {
					System.out.print("子节点=" + child.data);
					preOrder(child, flag, value);
				}
			}
		}
	}

测试

public class testTree {
	public static void main(String[] args) {
		Node node=new Node(100l);
		Tree tree = new Tree(node);
		long[]seconds={1,2,3,4,5,6,7,8,9};
		for(long second: seconds){
		//100l是根节点，添加9个子节点
			tree.insert(second, 100l);
				for(int i=10;i<20;i++){
					//每个节点下面添加10个子节点
					tree.insert(second*i, second);
					//可以再添加几层
			}
		}
		//遍历指定节点的所有子节点
		tree.preOrder(100l);
		tree.find(55l);
	}
}