精华内容
下载资源
问答
  • java多叉树的实现:节点集合生成多叉树,单个节点添加到多叉树,深度遍历,广度遍历
  • Java实现多叉树查找

    2020-12-22 20:07:26
     3 import java.util.List;  4 import java.util.ArrayList;  5 import java.io.Serializable;  6  7 public class TreeNode implements Serializable {  8 private int parentId;  9 private int ...
  • java多叉树

    2018-12-06 11:03:58
    uctor public class Node { private Node parent; private String name; private int rank; //同级排行 private int level;//层级 private List<Node&...
    1.建立节点对象
    <wiz_code_mirror>
     
     
     
     
     
    @Getter
    @Setter
    @Builder(builderClassName = "NodeBuilder")
    @NoArgsConstructor
    @AllArgsConstructor
    public class Node {
        private Node parent;
        private String name;
        private int rank; //同级排行
        private int level;//层级
        private List<Node> childrens=new ArrayList<Node>();
    }
     
     
    2.插入对象   先插入3层每层3个子节点
    <wiz_code_mirror>
     
     
     
     
     
       @Test
        public void addNode(){
            Node.NodeBuilder builder = Node.builder();
            Node a = builder.level(1).name("a").rank(1).parent(null).childrens(new ArrayList<Node>()).build();
            createTree(a);
    //        queryTree(a);//从上往下一直查找再返回上一层查找
            querylevelTree(a);//一层一层查找
            return;
        }
    public void createTree(Node parent){
                if(parent.getLevel()>2){//建立3层 父节点层级大于2就退出
                    return;
                }else {
                    for (int i = 0; i < 3; i++) {
                        int level = parent.getLevel() + 1;
                        Node node = createNode(level, "a" + level +parent.getRank() +"-"+i, parent,i);
                        parent.getChildrens().add(node);
                        createTree(node);//递归建立子节点
                    }
                }
        }
     
        public Node createNode(int level,String name,Node parent,int rank){
            Node.NodeBuilder builder = Node.builder();
            Node a = builder.level(level).name(name).childrens(new ArrayList<Node>()).parent(parent).rank(rank).build();
            return a;
        }
     
     
    3.查找子节点方法一(从顶部往底部查找)
    <wiz_code_mirror>
     
     
     
     
     
    public void queryTree(Node a){
            System.out.println(a.getName());
            if(a.getChildrens()!=null&&a.getChildrens().size()>0){
                List<Node> childrens = a.getChildrens();
                for(int i = 0; i< childrens.size();i++){
                    queryTree(childrens.get(i));
                }
            }else {//没有子节点退出循环
                return;
            }
       }
     
     
    输出
    a
    a21-0
    a30-0
    a30-1
    a30-2
    a21-1
    a31-0
    a31-1
    a31-2
    a21-2
    a32-0
    a32-1
    a32-2
    4.查找子节点方法二(一层一层查找)
    <wiz_code_mirror>
     
     
     
     
     
     public void querylevelTree(Node a){
            if(a.getChildrens()!=null&&a.getChildrens().size()>0){
                List<Node> childrens = a.getChildrens();
                for(int i = 0; i< childrens.size();i++){//先把当前层查找完  再查找下一层
                    System.out.println(childrens.get(i).getName());
                }
                for(int i = 0; i< childrens.size();i++){//查找下一层
                    querylevelTree(a.getChildrens().get(i));
                }
            }else {//没有子节点退出循环
                return;
            }
        }
     
     
    输出
    a21-0
    a21-1
    a21-2
    a30-0
    a30-1
    a30-2
    a31-0
    a31-1
    a31-2
    a32-0
    a32-1
    a32-2
    展开全文
  • java多叉树的遍历

    千次阅读 2019-01-23 08:54:26
    用过了二叉树后,正好业务上有一个需求,就是需要求出从根节点到每个叶子节点的路径集合,由于不是二叉树,而是如同一种多叉树的结构,下面来看具体代码, 1、节点对象,包含3个属性,当前节点Id,持有的父节点Id,...

    用过了二叉树后,正好业务上有一个需求,就是需要求出从根节点到每个叶子节点的路径集合,由于不是二叉树,而是如同一种多叉树的结构,下面来看具体代码,

    1、节点对象,包含3个属性,当前节点Id,持有的父节点Id,当前节点的内容,

    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;
    	}
    
    }
    

    2、多节点,我理解的是某个包含了多个其他节点的节点,即这个ManyTreeNode实际上存储的是当前节点以及对其包含的多个节点的引用,

    public class ManyTreeNode {
    
    	private TreeNode data;
    
    	private List<ManyTreeNode> childList;
    
    	public ManyTreeNode(TreeNode data) {
    		this.data = data;
    		this.childList = new ArrayList<ManyTreeNode>();
    	}
    
    	public ManyTreeNode(TreeNode data, List<ManyTreeNode> childList) {
    		this.data = data;
    		this.childList = childList;
    	}
    
    	public TreeNode getData() {
    		return data;
    	}
    
    	public void setData(TreeNode data) {
    		this.data = data;
    	}
    
    	public List<ManyTreeNode> getChildList() {
    		return childList;
    	}
    
    	public void setChildList(List<ManyTreeNode> childList) {
    		this.childList = childList;
    	}
    
    }
    

    3、多叉树节点的操作,插入,遍历等,

    public class ManyNodeTree {
    
    	/** 树根 */
    	private ManyTreeNode root;
    
    	public ManyNodeTree() {
    		root = new ManyTreeNode(new TreeNode("root"));
    	}
    
    	// 生成一个多茶树,根节点为root
    	public ManyNodeTree createTree(List<TreeNode> 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;
    	}
    
    	// 向指定多叉树节点添加子节点
    	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);
    				}
    			}
    		}
    
    	}
    
    	// 遍历多叉树
    	public String iteratorTree(ManyTreeNode manyTreeNode) {
    		List<String> rsData = new ArrayList<>();
    		StringBuilder buffer = new StringBuilder();
    		buffer.append("|");
    		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) {
    		List<TreeNode> treeNodes = new ArrayList<TreeNode>();
    		
    		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()));
    		System.out.println("-------------");
    		String result = tree.iteratorTree(tree.createTree(treeNodes).getRoot());
    		
    	}
    
    }
    

    运行一下main函数,可以打印出从root开始到各个最终的子节点的值

    展开全文
  • java多叉树层次遍历

    千次阅读 2018-05-28 23:13:55
    java多叉树的层次遍历,我的树好像不太一样,看代码吧。代码中的LLQueue 就是一个单链表实现的队列。 思路与二叉树的层次遍历一样。遍历一层的时候,把下层的节点放到队列中。就是操作有点不同。 /** * 功能 : ...

    java多叉树的层次遍历,我的树好像不太一样大笑,看代码吧。代码中的LLQueue 就是一个单链表实现的队列。

    思路与二叉树的层次遍历一样。遍历一层的时候,把下层的节点放到队列中。就是操作有点不同。

    /**
     * 功能 :
     * date : 2018/5/28
     *
     * @author : zcwang@wisdombud.com
     * @version : 0.0.4-snapshot
     * @since : JDK 1.8
     */
    public class TreeNode<T> {
        T data;
        private TreeNode<T> firstChild;
        private TreeNode<T> nextSibling;
    
        public TreeNode(final T data, final TreeNode<T> firstChild, final TreeNode<T> nextSibling) {
            this.data = data;
            this.firstChild = firstChild;
            this.nextSibling = nextSibling;
        }
    
        public TreeNode(final T data) {
            this(data, null, null);
        }
    
        public static void main(String args[]) {
            TreeNode<Integer> treeNode = new TreeNode<>(1);
            TreeNode<Integer> firstChild = new TreeNode<>(2);
            TreeNode<Integer> nextSibling = new TreeNode<>(3);
            TreeNode<Integer> nextSibling1 = new TreeNode<>(4);
            TreeNode<Integer> nextSibling2 = new TreeNode<>(5);
    
            TreeNode<Integer> firstChild1 = new TreeNode<>(6);
            TreeNode<Integer> nextSibling11 = new TreeNode<>(7);
            TreeNode<Integer> nextSibling12 = new TreeNode<>(8);
    
            TreeNode<Integer> firstChild2 = new TreeNode<>(9);
            TreeNode<Integer> nextSibling21 = new TreeNode<>(10);
            TreeNode<Integer> nextSibling22 = new TreeNode<>(11);
            treeNode.setFirstChild(firstChild);
            firstChild.setNextSibling(nextSibling);
            nextSibling.setNextSibling(nextSibling1);
            nextSibling1.setNextSibling(nextSibling2);
    
            nextSibling.setFirstChild(firstChild1);
            firstChild1.setNextSibling(nextSibling11);
            nextSibling11.setNextSibling(nextSibling12);
    
            nextSibling1.setFirstChild(firstChild2);
            firstChild2.setNextSibling(nextSibling21);
            nextSibling21.setNextSibling(nextSibling22);
            levelOrder(treeNode);
        }
    
        public static void levelOrder(TreeNode<Integer> root) {
            if (root == null) {
                return;
            }
            TreeNode<Integer> temp;
            LLQueue<TreeNode> queue = new LLQueue<>();
            queue.enQueue(root);
            while (!queue.isEmpty()) {
                temp = queue.deQueue();
                System.out.println(temp.getData());
                //判断是否存在孩子节点
                if (temp.getFirstChild() != null) {
                    queue.enQueue(temp.getFirstChild());
                    temp = temp.getFirstChild();
                    // 如果存在兄弟 就一直向queue中放
                    while (temp.getNextSibling() != null) {
                        queue.enQueue(temp.getNextSibling());
                        temp = temp.getNextSibling();
                    }
                }
            }
        }
    }

     

     

     

    展开全文
  • 在实现基本多叉树的基础上,个性化拓展了实现了得到某个节点的全部递归子节点,孤独子节点,第一层级子节点对应的全部递归子节点等数据的功能处理。
  • Java 多叉树的实现,完成树的初始化和遍历。包括两个文件(TreeNode.java和TreeHelper.java) TreeNode类完成树节点的数据结构,TreeHelper类通过输入一个TreeNode列表,生成一颗有一个树根的树!其它函数接口自己看...

    转载资源,原地址:https://ylq365.iteye.com/blog/980627

    Java 多叉树的实现,完成树的初始化和遍历。包括两个文件(TreeNode.java和TreeHelper.java) 
    TreeNode类完成树节点的数据结构,TreeHelper类通过输入一个TreeNode列表,生成一颗有一个树根的树!其它函数接口自己看看就明白了,希望对你有帮助。 

    一:树节点的定义(TreeNode.java) 

    package com.tree;  
      
    import java.util.List;  
    import java.util.ArrayList;  
    import java.io.Serializable;  
      
    public class TreeNode implements Serializable {  
        private int parentId;  
        private int selfId;  
        protected String nodeName;  
        protected Object obj;  
        protected TreeNode parentNode;  
        protected List<TreeNode> childList;  
      
        public TreeNode() {  
            initChildList();  
        }  
      
        public TreeNode(TreeNode parentNode) {  
            this.getParentNode();  
            initChildList();  
        }  
      
        public boolean isLeaf() {  
            if (childList == ) {  
                return true;  
            } else {  
                if (childList.isEmpty()) {  
                    return true;  
                } else {  
                    return false;  
                }  
            }  
        }  
      
        /* 插入一个child节点到当前节点中 */  
        public void addChildNode(TreeNode treeNode) {  
            initChildList();  
            childList.add(treeNode);  
        }  
      
        public void initChildList() {  
            if (childList == )  
                childList = new ArrayList<TreeNode>();  
        }  
      
        public boolean isValidTree() {  
            return true;  
        }  
      
        /* 返回当前节点的父辈节点集合 */  
        public List<TreeNode> getElders() {  
            List<TreeNode> elderList = new ArrayList<TreeNode>();  
            TreeNode parentNode = this.getParentNode();  
            if (parentNode == ) {  
                return elderList;  
            } else {  
                elderList.add(parentNode);  
                elderList.addAll(parentNode.getElders());  
                return elderList;  
            }  
        }  
      
        /* 返回当前节点的晚辈集合 */  
        public List<TreeNode> getJuniors() {  
            List<TreeNode> juniorList = new ArrayList<TreeNode>();  
            List<TreeNode> childList = this.getChildList();  
            if (childList == ) {  
                return juniorList;  
            } else {  
                int childNumber = childList.size();  
                for (int i = 0; i < childNumber; i++) {  
                    TreeNode junior = childList.get(i);  
                    juniorList.add(junior);  
                    juniorList.addAll(junior.getJuniors());  
                }  
                return juniorList;  
            }  
        }  
      
        /* 返回当前节点的孩子集合 */  
        public List<TreeNode> getChildList() {  
            return childList;  
        }  
      
        /* 删除节点和它下面的晚辈 */  
        public void deleteNode() {  
            TreeNode parentNode = this.getParentNode();  
            int id = this.getSelfId();  
      
            if (parentNode != ) {  
                parentNode.deleteChildNode(id);  
            }  
        }  
      
        /* 删除当前节点的某个子节点 */  
        public void deleteChildNode(int childId) {  
            List<TreeNode> childList = this.getChildList();  
            int childNumber = childList.size();  
            for (int i = 0; i < childNumber; i++) {  
                TreeNode child = childList.get(i);  
                if (child.getSelfId() == childId) {  
                    childList.remove(i);  
                    return;  
                }  
            }  
        }  
      
        /* 动态的插入一个新的节点到当前树中 */  
        public boolean insertJuniorNode(TreeNode treeNode) {  
            int juniorParentId = treeNode.getParentId();  
            if (this.parentId == juniorParentId) {  
                addChildNode(treeNode);  
                return true;  
            } else {  
                List<TreeNode> childList = this.getChildList();  
                int childNumber = childList.size();  
                boolean insertFlag;  
      
                for (int i = 0; i < childNumber; i++) {  
                    TreeNode childNode = childList.get(i);  
                    insertFlag = childNode.insertJuniorNode(treeNode);  
                    if (insertFlag == true)  
                        return true;  
                }  
                return false;  
            }  
        }  
      
        /* 找到一颗树中某个节点 */  
        public TreeNode findTreeNodeById(int id) {  
            if (this.selfId == id)  
                return this;  
            if (childList.isEmpty() || childList == ) {  
                return ;  
            } else {  
                int childNumber = childList.size();  
                for (int i = 0; i < childNumber; i++) {  
                    TreeNode child = childList.get(i);  
                    TreeNode resultNode = child.findTreeNodeById(id);  
                    if (resultNode != ) {  
                        return resultNode;  
                    }  
                }  
                return ;  
            }  
        }  
      
        /* 遍历一棵树,层次遍历 */  
        public void traverse() {  
            if (selfId < 0)  
                return;  
            print(this.selfId);  
            if (childList ==  || childList.isEmpty())  
                return;  
            int childNumber = childList.size();  
            for (int i = 0; i < childNumber; i++) {  
                TreeNode child = childList.get(i);  
                child.traverse();  
            }  
        }  
      
        public void print(String content) {  
            System.out.println(content);  
        }  
      
        public void print(int content) {  
            System.out.println(String.valueOf(content));  
        }  
      
        public void setChildList(List<TreeNode> childList) {  
            this.childList = childList;  
        }  
      
        public int getParentId() {  
            return parentId;  
        }  
      
        public void setParentId(int parentId) {  
            this.parentId = parentId;  
        }  
      
        public int getSelfId() {  
            return selfId;  
        }  
      
        public void setSelfId(int selfId) {  
            this.selfId = selfId;  
        }  
      
        public TreeNode getParentNode() {  
            return parentNode;  
        }  
      
        public void setParentNode(TreeNode parentNode) {  
            this.parentNode = parentNode;  
        }  
      
        public String getNodeName() {  
            return nodeName;  
        }  
      
        public void setNodeName(String nodeName) {  
            this.nodeName = nodeName;  
        }  
      
        public Object getObj() {  
            return obj;  
        }  
      
        public void setObj(Object obj) {  
            this.obj = obj;  
        }  
    }  
    

    二:TreeHelper.java 

    package com.tree;  
      
    import java.util.List;  
    import java.util.Iterator;  
    import java.util.ArrayList;  
    import java.util.HashMap;  
      
    public class TreeHelper {  
      
        private TreeNode root;  
        private List<TreeNode> tempNodeList;  
        private boolean isValidTree = true;  
      
        public TreeHelper() {  
        }  
      
        public TreeHelper(List<TreeNode> treeNodeList) {  
            tempNodeList = treeNodeList;  
            generateTree();  
        }  
      
        public static TreeNode getTreeNodeById(TreeNode tree, int id) {  
            if (tree == )  
                return ;  
            TreeNode treeNode = tree.findTreeNodeById(id);  
            return treeNode;  
        }  
      
        /** generate a tree from the given treeNode or entity list */  
        public void generateTree() {  
            HashMap nodeMap = putNodesIntoMap();  
            putChildIntoParent(nodeMap);  
        }  
      
        /** 
         * put all the treeNodes into a hash table by its id as the key 
         *  
         * @return hashmap that contains the treenodes 
         */  
        protected HashMap putNodesIntoMap() {  
            int maxId = Integer.MAX_VALUE;  
            HashMap nodeMap = new HashMap<String, TreeNode>();  
            Iterator it = tempNodeList.iterator();  
            while (it.hasNext()) {  
                TreeNode treeNode = (TreeNode) it.next();  
                int id = treeNode.getSelfId();  
                if (id < maxId) {  
                    maxId = id;  
                    this.root = treeNode;  
                }  
                String keyId = String.valueOf(id);  
      
                nodeMap.put(keyId, treeNode);  
                // System.out.println("keyId: " +keyId);  
            }  
            return nodeMap;  
        }  
      
        /** 
         * set the parent nodes point to the child nodes 
         *  
         * @param nodeMap 
         *            a hashmap that contains all the treenodes by its id as the key 
         */  
        protected void putChildIntoParent(HashMap nodeMap) {  
            Iterator it = nodeMap.values().iterator();  
            while (it.hasNext()) {  
                TreeNode treeNode = (TreeNode) it.next();  
                int parentId = treeNode.getParentId();  
                String parentKeyId = String.valueOf(parentId);  
                if (nodeMap.containsKey(parentKeyId)) {  
                    TreeNode parentNode = (TreeNode) nodeMap.get(parentKeyId);  
                    if (parentNode == ) {  
                        this.isValidTree = false;  
                        return;  
                    } else {  
                        parentNode.addChildNode(treeNode);  
                        // System.out.println("childId: " +treeNode.getSelfId()+" parentId: "+parentNode.getSelfId());  
                    }  
                }  
            }  
        }  
      
        /** initialize the tempNodeList property */  
        protected void initTempNodeList() {  
            if (this.tempNodeList == ) {  
                this.tempNodeList = new ArrayList<TreeNode>();  
            }  
        }  
      
        /** add a tree node to the tempNodeList */  
        public void addTreeNode(TreeNode treeNode) {  
            initTempNodeList();  
            this.tempNodeList.add(treeNode);  
        }  
      
        /** 
         * insert a tree node to the tree generated already 
         *  
         * @return show the insert operation is ok or not 
         */  
        public boolean insertTreeNode(TreeNode treeNode) {  
            boolean insertFlag = root.insertJuniorNode(treeNode);  
            return insertFlag;  
        }  
      
        /** 
         * adapt the entities to the corresponding treeNode 
         *  
         * @param entityList 
         *            list that contains the entities 
         *@return the list containg the corresponding treeNodes of the entities 
         */  
        public static List<TreeNode> changeEnititiesToTreeNodes(List entityList) {  
            OrganizationEntity orgEntity = new OrganizationEntity();  
            List<TreeNode> tempNodeList = new ArrayList<TreeNode>();  
            TreeNode treeNode;  
      
            Iterator it = entityList.iterator();  
            while (it.hasNext()) {  
                orgEntity = (OrganizationEntity) it.next();  
                treeNode = new TreeNode();  
                treeNode.setObj(orgEntity);  
                treeNode.setParentId(orgEntity.getParentId());  
                treeNode.setSelfId(orgEntity.getOrgId());  
                treeNode.setNodeName(orgEntity.getOrgName());  
                tempNodeList.add(treeNode);  
            }  
            return tempNodeList;  
        }  
      
        public boolean isValidTree() {  
            return this.isValidTree;  
        }  
      
        public TreeNode getRoot() {  
            return root;  
        }  
      
        public void setRoot(TreeNode root) {  
            this.root = root;  
        }  
      
        public List<TreeNode> getTempNodeList() {  
            return tempNodeList;  
        }  
      
        public void setTempNodeList(List<TreeNode> tempNodeList) {  
            this.tempNodeList = tempNodeList;  
        }  
      
    }  

    三 实体OrganizationEntity 

    package com.tree;  
      
    public class OrganizationEntity {  
        public int parentId;  
        public int orgId;  
        public String orgName;  
        public int getParentId() {  
            return parentId;  
        }  
        public void setParentId(int parentId) {  
            this.parentId = parentId;  
        }  
        public int getOrgId() {  
            return orgId;  
        }  
        public void setOrgId(int orgId) {  
            this.orgId = orgId;  
        }  
        public String getOrgName() {  
            return orgName;  
        }  
        public void setOrgName(String orgName) {  
            this.orgName = orgName;  
        }  
    }  

     

    展开全文
  • /**  * 〈一句话功能简述〉... * 遍历同时保存该节点中的parentNode属性  *  * @param treeNode  */  public void traverseTreeAndSaveParentNode(TreeNode treeNode) {  if (ownId ) { ...
  • Java 多叉树的简单实现

    千次阅读 2017-05-27 18:58:22
    Java 多叉树的简单实现
  • java多叉树的生成和遍历

    千次阅读 2017-04-28 19:39:40
    转载另外一个关于多叉树的实现类: TreeNode.Java [java] view plain copy /* * Copyright Walker Studio * All Rights Reserved. * * 文件名称: TreeNode.java * 摘 要: * ...
  • 最近课程设计做了个多叉树的书目分类管理系统。但愿有点用吧。。。 主菜单的代码就免了,我直接上方法咯 需要 测试代码的可留言 原创 可能会有很多不足 请多指教 public class Node { private String id; //节点...
  • 因为项目需要简历一个森林来保存图形之间的父子关系,因此建立一种多叉树作为验证模型。具体原理如下草稿所示:实现代码如下:package com.test.forest; import java.util.ArrayList; import java.util.List; ...
  • 我用了多叉树广度优先搜索,遍历了文件的树形结构,然后用回调方法判断文件或文件夹是否符合搜索条件。把结果返回到一个集合中。演示的例子分成三个文件:FileFilter、SearchFileUtils和Main。下面逐个给出代码。...
  • 求一个java多叉树结构

    2018-09-28 03:10:58
    - 如下数据: <th>id <th>parent <td>1 <td>null <td>2 <td>null ...目标将如此list数据转为多叉树结构(效率第一),注意目标数据是list,最终为多叉树list,坐等解决
  • Java实现对多叉树的操作

    千次阅读 2019-09-01 21:06:17
    Java多叉树前言我们实现下面这颗树Show Code?节点对象多叉树对象测试测试代码测试效果 前言 前段时间遇到的一个需求,前台需要实现一个类似于思维导图的页面,并且就一个页面,项目不是思维导图项目。 所以打算以...
  • ![图片说明](https://img-ask.csdn.net/upload/201606/03/1464922696_781096.png)
  • 现了一个多叉树建立函数,建立函数根据用户的输入,首先建立一个新的节点,然后根据B的值进行深度递归调用。用户输入节点的顺序就是按照深度递归的顺序。另外,我们实现了一个层次优先遍历函数。该函数用一个队列...
  • import java.util.LinkedList; import java.util.List; import java.util.Queue; import java.util.Stack; public class Search { //二叉树 public class TreeNode { int val; TreeNode left; TreeNode ri....
  • java多叉树遍历

    2018-08-09 09:25:54
    给出一棵多叉树,每个节点的任意两个子节点都有左右之分。从根节点开始尽量往左走,走不通就回溯,把遇到的字母记录下来,可以得到一个序列,给定一个序列,问有多少棵树与之相应。 分析:设输入的序列为S,d(i,j)...
  • 一、二叉树的问题分析 1)、 二叉树的操作效率较高,但是也存在问题, 请看下面的二叉树 2)、二叉树需要加载到内存的,如果二叉树的节点...如果允许每个节点可以有更多的数据项和更多的子节点,就是多叉树(multiway t
  • 使用Java简单实现多叉树的遍历结点个数与插入结点 多叉树结点定义 class Node { public int id; public List<Node> sonList; public int getId() { return id; } public Node(int id,List<Node> ...
  • java 多叉树遍历

    千次阅读 2010-03-23 14:54:00
    java 多叉树的遍历 写了二叉的遍历之后,发现多叉也一样的,而且java提供的容器类很方便,手工构造了一颗多叉树。然后再递归遍历。类似于中序遍历吧。 树的节点类: Java代码 复制代码" onclick="function onclick()...
  • 多叉树的建立以及后序非递归遍历,希望对学习数据结构的同学有所帮助,也对树一部分有更深的了解。
  • 新概念智能树形菜单--利用加权多叉树结合
  • java 多叉树的遍历

    2009-09-06 11:11:43
    接上一篇,昨天一朋友问我java中怎么实现多叉树的遍历,想了半天都没想出来,写了二叉的遍历之后,发现多叉也一样的,而且java提供的容器类很方便,比c语言里处理指针方便多了。 我手工构造了一颗多叉树。然...
  • 项目描述 最近使用SSM做后台系统,已经使用递归的形式动态获取到多级菜单,现写一个多级菜单的管理程序,用于直接遍历出所有菜单,并实现创建菜单以及对菜单的管理与删除。...1、先创建多叉树主节点主节点的pid=n...
  • java list集合转多叉树结构工具类

    万次阅读 2018-09-28 17:46:07
    因为项目需求,修改将如下数据格式的数据转为结构数据: id parent 1 null 2 null 3 null 4 1 5 1 6 1 7 2 8 2 9 3 10 4 11 7 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 3,499
精华内容 1,399
关键字:

java多叉树

java 订阅