使用递归算法从给定树上任意几个节点将这几个节点的所有下级 和 上级返回出来

递归算法是把问题转化为规模缩小了的同类问题的子问题,然后递归调用函数(或过程)来表示问题的解。数学上常见的例子有阶乘,斐波那契数列等。那么今天我将为大家讲解下实际开发过程中会遇到的案例。我们在项目中一般处理树形结构的节点上下级关系中用到递归算法。

下面是一个递归的案例。
给你一组数据,根据ID和PID组织成树形结构。
给定树上任意几个节点,将这几个节点的所有下级 和 上级返回出来。
组织Node实例,建立为下面的树形结构。

1
|--11
| |--111
| |--1111
|--12
|--121
| |--1211
|--122
|--1221
给定节点 111,则返回数据有 1,11,111,1111
给定节点 121,则返回1,12,121,1211
给定节点 12,则返回1,12,121,1211,122,1221
给定节点 111 和 1211,则返回1,11,111,111,12,121,1211

备注:组织树性结构时,对于无效数据,找不到上级的节点,作为根来处理。

  1. 首先,创建名称为Node的节点类,用来存放节点属性
    import java.util.ArrayList;
    
    public class Node {
    	public String ID = null;       //节点id
    	public String PID = null;		//父节点id
    	public Node(String ID1, String ID2)
    	{
    		this.ID = ID1;
    		this.PID = ID2;
    	}
    	//定义上一节点变量
    	public Node upNode = null;
    	//定义向下节点集合
    	public ArrayList<Node> subList = new ArrayList<Node>();
    }
    

  2. 其次,创建名称为Test的处理类,用来进行递归实现题目运算
    import java.util.ArrayList;
       import java.util.HashMap;
       import java.util.List;
       public class Test
       {
    	public static void main(String[] args)
    	{	
    		//创建集合,建立题目中的树形结构
    		List<Node> list = new ArrayList<Node>();
    		list.add(new Node("1", ""));
    		list.add(new Node("11", "1"));
    		list.add(new Node("12", "1"));
    		list.add(new Node("111", "11"));
    		list.add(new Node("1111", "111"));
    		list.add(new Node("121", "12"));
    		list.add(new Node("122", "12"));
    		list.add(new Node("1211", "121"));
    		list.add(new Node("1221", "122"));
    		
            //使用hashmap存放节点
    		HashMap<String, Node> nodeMap = new HashMap<String, Node>();
    		for (Node node : list)
    		{
    			//将ID对应的node放到HashMap中
    			nodeMap.put(node.ID, node);
    		}
    	
    		//创建动态数组,用来处理顶级节点“1”
    		List<Node> toplist = new ArrayList<Node>();
    		
    		for (Node node : list)
    		{
    			if(node.PID != null && !"".equals(node.PID))
    			{
    				Node upNode = nodeMap.get(node.PID);
    				if(upNode != null)
    				{
    					// 添加下级
    					upNode.subList.add(node);
    					// 设置上级
    					node.upNode = upNode;
    				}else
    				{
    					toplist.add(node);
    				}
    			}
    			else
    			{
    				toplist.add(node);
    			}
    		}
    		
    		// 给定节点 111,则返回数据有 1,11,111,1111
    	
    		System.out.println(getNode("111", nodeMap));
    
    		// 给定节点 121,则返回1,12,121,1211
    		System.out.println(getNode("121", nodeMap));
    
    		// 给定节点 12,则返回1,12,121,1211,122,1221
    		System.out.println(getNode("12", nodeMap));
    
    		// 给定节点 111 和 1211,则返回1,11,111,111,12,121,1211
    		System.out.println(getNode("1211", nodeMap));
    	}
    
    	private static String getNode(String id, HashMap<String, Node> nodeMap)
    	{
    		Node node = nodeMap.get(id);
    		if(node == null)
    		{
    			return "Node不存在!";
    		}
    		else
    		{
    			List<Node> resultList = new ArrayList<Node>();
    			getNodeUpNode(node, resultList);
    			getNodeSubNode(node, resultList);
    			boolean bFirst = true;
    			StringBuffer sb = new StringBuffer();
    			for (Node t : resultList)
    			{
    				if(bFirst)
    				{
    					bFirst = false;
    				}
    				else
    				{
    					sb.append(",");
    				}
    				sb.append(t.ID);
    			}
    			return sb.toString();
    		}
    		
    		
    	}
    	//获取给定节点的上级节点
    	private static void getNodeUpNode(Node node, List<Node> resultList)
    	{
    		if(node.upNode != null)
    		{
    			//递归调用
    			getNodeUpNode(node.upNode, resultList);
    		}
    		resultList.add(node);
    
    	}
    	//获取给定节点的下级节点
    	private static void getNodeSubNode(Node node, List<Node> resultList)
    	{
    		for (Node subNode : node.subList)
    		{
    			//递归调用
    			resultList.add(subNode);
    			getNodeSubNode(subNode, resultList);
    			
    		}
    	}
       }
    
  3. 最后,运行即可输出如题结果

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值