`
myCsdn_taoge
  • 浏览: 40353 次
  • 性别: Icon_minigender_1
  • 来自: 沈阳
文章分类
社区版块
存档分类
最新评论

一个简单的java Tree

 
阅读更多

一个Node实体类:

package com.design.patterns.composite;

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

public class Node {
	  // 编号
	  private long id;

	  // 标题
	  private String title;

	  // 下级列表
	  private List<Node> children = new ArrayList<Node>();

	  // 上级,顶层为null
	  private Node parent;

	  // 前一个节点
	  private Node prev;

	  // 后一个节点
	  private Node next;

	  // 当前处理的节点
	  private Node current;

	  /**
	   * 默认的构造器
	   */
	  public Node() {
	  }

	  /**
	   * 推荐使用的构造器
	   * 
	   * @param id 编号
	   * @param title 文本
	   */
	  public Node(long id, String title) {
	    this.id = id;
	    this.title = title;
	  }

	  /**
	   * 增加一个下属。<br>
	   * 自动对应上级和兄弟结点
	   * 
	   * @param n 被增加的节点
	   */
	  public void addChild(Node n) {
	    children.add(n);
	    n.setParent(this);
	    if (current != null) {
	      current.next = n;
	    }
	    n.prev = current;
	    current = n;
	  }

	  /**
	   * 输出为下拉列表的方法
	   * 
	   * @param selectedId 被选中的编号
	   * @return 下拉列表的字符串。可以直接放到<select></select>里面
	   */
	  public String getOption(long selectedId) {
	    return "<option>" + toStringOption("", "", selectedId);
	  }

	  /**
	   * 输出为Text的方法。<br>
	   * 应网友建议,更改toString为toStringText方法。
	   * 
	   * @param lftStr 左侧额外的字符串
	   * @param append 右侧显示的字符串
	   * @return 文本形式的字符串
	   */
	  public String toStringText(String lftStr, String append) {
	    StringBuilder b = new StringBuilder();
	    b.append(append + title);
	    b.append(" ");
	    if (children.size() > 0) {
	      for (int i = 0; i < children.size() - 1; i++) {
	        b.append(lftStr + children.get(i).toStringText(lftStr + "│", "├"));
	      }
	      b.append(lftStr + children.get(children.size() - 1).toStringText(lftStr + " ", "└"));
	    }
	    return b.toString();
	  }

	  public static void main(String[] args) {
	    Node root = new Node(0, "菜单列表");
	    Node f1 = new Node(1, "开始菜单");
	    root.addChild(f1);
	    Node f1_1 = new Node(11, "程序");
	    f1.addChild(f1_1);
	    Node f1_1_1 = new Node(111, "附件");
	    f1_1.addChild(f1_1_1);
	    Node f1_1_1_1 = new Node(1111, "娱乐");
	    f1_1_1.addChild(f1_1_1_1);
	    Node f1_1_1_2 = new Node(1112, "娱乐2");
	    f1_1_1.addChild(f1_1_1_2);
	    Node f1_2 = new Node(12, "辅助工具");
	    f1.addChild(f1_2);
	    Node f2 = new Node(2, "My Documents ");
	    root.addChild(f2);
	    Node f3 = new Node(3, "My Documents2 ");
	    root.addChild(f3);
	    System.out.println(root.toStringText(" ", ""));
	    System.out.println(root.getOption(111));
	    System.out.println(f1_1_1_2.getPrev().getTitle());
	    System.out.println(f1_1_1_2.getPrev().getParent().getTitle());
	  }

	  public List<Node> getChildren() {
	    return children;
	  }

	  public long getId() {
	    return id;
	  }

	  /**
	   * 得到下一个兄弟结点。
	   * 
	   * @return 如果是最后一个,则返回null
	   */
	  public Node getNext() {
	    return next;
	  }

	  public Node getParent() {
	    return parent;
	  }

	  /**
	   * 得到前一个兄弟结点。
	   * 
	   * @return 如果是第一个,则返回null
	   */
	  public Node getPrev() {
	    return prev;
	  }

	  public String getTitle() {
	    return title;
	  }

	  public void setId(long id) {
	    this.id = id;
	  }

	  public void setNext(Node next) {
	    this.next = next;
	  }

	  public void setParent(Node parent) {
	    this.parent = parent;
	  }

	  public void setPrev(Node prev) {
	    this.prev = prev;
	  }

	  public void setTitle(String title) {
	    this.title = title;
	  }

	  /**
	   * 构造下拉列表.
	   * 
	   * @param lftStr 左侧的字符
	   * @param append 增加的字符
	   * @param idSelected 被选中的编号
	   * @return 下拉列表字符串
	   */
	  private String toStringOption(String lftStr, String append, long idSelected) {
	    StringBuilder b = new StringBuilder();
	    b.append(append + title + "</option>");
	    b.append(" ");
	    if (children.size() > 0) {
	      for (int i = 0; i < children.size() - 1; i++) {
	        b.append("<option value='" + children.get(i).getId() + "'" + (idSelected == children.get(i).getId() ? " selected" : "")
	            + ">" + lftStr + children.get(i).toStringOption(lftStr + "│", "├", idSelected));
	      }
	      b.append("<option value='" + children.get(children.size() - 1).getId() + "'"
	          + (idSelected == children.get(children.size() - 1).getId() ? " selected" : "") + ">" + lftStr
	          + children.get(children.size() - 1).toStringOption(lftStr + " ", "└", idSelected));
	    }
	    return b.toString();
	  }
}

 树形结构的构造类:

package com.design.patterns.composite;

import java.util.ArrayList;
import java.util.List;
/*
 * 树形结构
 */
public class TreeNode<T> {
	
	public T t;
	private String id;  
	private String nodeName;  
    private TreeNode<T> parent;  
    private List<TreeNode<T>> childrenList = new ArrayList<TreeNode<T>>();
    
    
    public TreeNode(String id,String nodeName) {
		// TODO Auto-generated constructor stub
    	this.id=id;
    	this.nodeName=nodeName;
	}
    
    /*
     * 添加一个节点
     */
    public void add(TreeNode<T> node) {
    	this.childrenList.add(node);
    	node.setParent(this);
	}
    
    /*
     * 删除一个节点
     */
    public void remove(TreeNode<T> node) {
    	childrenList.remove(node);
    }
    
   //取得孩子节点  
    public List<TreeNode<T>> getChildren(){ 
    	
    	return childrenList;
    } 
    
    //展示该节点下的所有孩子节点  
    public void showAllNodes(TreeNode<T> node){ 
    	
    	if (node != null) {
    		System.out.println(node.getNodeName().toString());
				
			for (int i = 0; i < node.childrenList.size(); i++) {
				TreeNode<T> nodes=node.childrenList.get(i);
//				System.out.println(nodes.getNodeName());
				showAllNodes(nodes);
			}
		}
    }  
    
    //展示该节点下的下层节点  
    public void showNextNodes(TreeNode<T> node){ 
    	
    	if (node != null) {
//    		System.out.println(node.getNodeName().toString());
    		
    		for (int i = 0; i < node.childrenList.size(); i++) {
    			TreeNode<T> nodes=node.childrenList.get(i);
//				System.out.println(nodes.getNodeName());
    			
    			if (this.id.equals(nodes.getParent().getId())) {
					System.out.println(nodes.getNodeName());
				}
//    			if (nodes.id.startsWith((this.id))&&nodes.id.length()==2) {
//					System.out.println(nodes.getNodeName());
//				}
//    			if (nodes.id.startsWith((this.id))&&nodes.id.length()==4) {
//    				System.out.println(nodes.getNodeName());
//    			}
//    			showNextNodes(nodes);
    		}
    	}
    }  
    
    
	public String getNodeName() {
		return nodeName;
	}
	
	
	public T getT() {
		return t;
	}

	public void setT(T t) {
		this.t = t;
	}

	public void setNodeName(String nodeName) {
		this.nodeName = nodeName;
	}

	public TreeNode<T> getParent() {
		return parent;
	}
	public void setParent(TreeNode<T> parent) {
		this.parent = parent;
	}

	public String getId() {
		return id;
	}

	public void setId(String id) {
		this.id = id;
	}
    
}

 一个测试类:

package com.design.patterns.composite;

import java.util.Enumeration;
import java.util.List;
import java.util.Vector;

public class Tree {
	
	TreeNode root=null;
	public Tree(String id,String name) {
		// TODO Auto-generated constructor stub
		this.root= new TreeNode(id,name);
	}
	
	public static void main(String[] args) {
		Tree tree=new Tree("0","根目录");
		
		TreeNode nodeB=new TreeNode("01","B");
		tree.root.add(nodeB);
		
		TreeNode nodeC=new TreeNode("01_1","C");
		nodeB.add(nodeC);
		
		TreeNode nodeD=new TreeNode("01_2","D");
		nodeB.add(nodeD);
		
		TreeNode nodeF=new TreeNode("01_3","F");
		nodeB.add(nodeF);
		
		TreeNode nodeE=new TreeNode("02","E");
		
		
		tree.root.add(nodeE);
		
//		nodeC.remove(nodeD);
		
//		TreeNode nodes =tree.root;
//		nodes.showNextNodes(nodes);
		nodeB.showNextNodes(nodeB);
		
		nodeB.remove(nodeF);
		
		List list = nodeB.getChildren();
		
		List list2 = tree.root.getChildren();
		
		
		TreeNode nodes =tree.root;
		nodes.showAllNodes(nodes);
		
		Vector v = new Vector();//是同步的,多线程情况下可以用这个,ArrayList 是非同步的,效率要比Vector高一些
		//向Vector中添加元素 
		//使用add方法直接添加元素 
		v.add("Test0"); 
		v.add("Test1"); 
		v.add("Test0"); 
		v.add("Test2"); 
		v.add("Test2");
		
		//从Vector中删除元素 
		v.remove("Test0"); //删除指定内容的元素 
		v.remove(0); //按照索引号删除元素
		//获得Vector中已有元素的个数 
		int size = v.size(); 
		System.out.println("size:" + size);
		//遍历Vector中的元素 
		for(int i = 0;i < v.size();i++){ 
			System.out.println(v.get(i)); 
		} 
		
	}
	
}

 

 

分享到:
评论

相关推荐

    简单java tree

    简单java tree 比较简单的demo,无限极菜单

    Javatree java树结构

    - 满二叉树(Full Binary Tree):每个节点要么有两个子节点,要么没有子节点,即没有只有一个子节点的情况。 - 平衡二叉树(Balanced Binary Tree):左右两个子树的高度差不超过1,并且每个节点都包含左子树和右...

    java tree的实现

    `Tree` 类代表了一个树形结构的整体,它包含一个根节点(`TreeNode`)和一个节点列表。该类提供了以下功能: - **获取根节点**:通过 `getRootNode()` 方法返回根节点。 - **添加节点**:`addNodes(TreeNode ...

    Java Tree的几种开源组件

    Apache Commons Collection库提供了一个Tree接口和相关的实现,如RedBlackTree和AVLTree。这些类实现了平衡二叉搜索树,保证了插入、删除和查找操作的时间复杂度为O(log n)。它们是高效的并发环境中管理有序数据的...

    java简单开发部门树(Tree)

    在Java开发中,构建部门树(Tree)是一个常见的需求,特别是在企业级应用中,用于展示组织结构或权限管理。这个项目提供了从JSP前端到Java后端的完整解决方案,非常适合初学者理解和学习,也能帮助有经验的开发者...

    javaTree的一个例子

    此示例通过`javaTree`创建了一个可动态扩展的树形结构,并将其集成到一个简单的Swing GUI中。代码主要由两部分组成:`Branch`类和`Tree`类。 #### 二、`Branch`类详解 `Branch`类负责创建树节点。它接受一个字符串...

    java Tree

    `TreeSet`是基于红黑树(Red-Black Tree)实现的,它是一个自平衡二叉查找树,保证了插入、删除和查找操作的时间复杂度为O(log n)。`TreeSet`不允许有重复元素,并且按照自然顺序或者用户提供的比较器进行排序。你...

    JAVA TREE

    在Java中实现树结构,我们通常会创建一个Node类,包含数据字段和指向子节点的引用。例如: ```java public class TreeNode { int val; TreeNode left; TreeNode right; TreeNode(int val) { this.val = val; ...

    java中tree的实现

    在Java编程语言中,"Tree"通常指的是数据结构中的树形结构,这是一个非线性的数据组织方式,模拟了自然界中的树状层次关系。在Java中,我们可以使用多种方式来实现树,包括但不限于自定义类、Java集合框架中的`...

    java中的tree

    在Java编程语言中,"Tree"是一个重要的数据结构,它以树形结构组织数据,具有节点(Node)的概念,每个节点可以有零个或多个子节点。这种数据结构非常适合表示层次关系,例如文件系统、组织架构或者计算机科学中的...

    java 生成 Tree.htm

    java 生成 Tree.htmjava 生成 Tree.htm

    jsTree JAVA例子

    根据提供的文件名 "testtree01",这可能是一个示例项目的名称,其中可能包含了集成 jsTree 和 Java 的代码示例。这个项目可能包含了前端的 HTML、CSS、JS 文件,以及后端的 Java 类和 JSON 响应示例。你可以通过查看...

    java tree在web上的实现

    "tree.war"是一个Web应用程序归档文件,它是Java Web应用的标准部署格式。war文件包含了所有必要的资源,如JSP页面、静态文件(如CSS和JavaScript)、图片以及WEB-INF目录下的配置文件(如web.xml)。你可以将此war...

    SR-tree-java.zip_java tree_sr tree_tree

    标题中的"SR-tree-java.zip_java tree_sr tree_tree"暗示了这是一个关于Java实现的SR树(Suffix-Radix Tree)的项目。SR树是一种高效的多维数据结构,常用于数据库索引和空间数据处理,它结合了后缀树(Suffix Tree...

    java_tree_demo.rar_DEMO_java tr_java tree Demo_java tree de

    Java Tree Demo是一个面向Java开发者的示例项目,它展示了如何在Java中实现树形数据结构以及相关的操作。这个项目可能包含一系列的版本,从最初的基础实现到最终的完善版本,以便展示开发过程中的演变。根据描述,源...

    B+ tree的java实现

    在"BPTree2"这个文件中,我们可以期待找到一个完整的Java实现,包括B+树的节点类、插入、查找、删除等核心功能。代码应该包含了详细的注释,解释了各个部分的功能和逻辑。通过阅读和理解这段代码,开发者可以深入...

    java Tree (jsp+javabea).rar_java tree_java tree jsp_jsp JavaBea

    在这个"java Tree (jsp+javabean)"的项目中,开发者使用JSP(JavaServer Pages)和JavaBean技术从数据库中动态地读取数据,然后构建一个可交互的目录树视图。 JSP是一种用于创建动态网页的技术,它允许开发人员在...

    用Java集合递归实现通用树Tree

    以下是一个简单的树节点类的示例: ```java public class TreeNode&lt;T&gt; { private T data; private List&lt;TreeNode&lt;T&gt;&gt; children; public TreeNode(T data) { this.data = data; this.children = new ArrayList...

    java 树 tree

    - 红黑树是一种自平衡二叉查找树,它的每个节点都有一个颜色属性,可以是红色或黑色。通过特定的规则保持树的平衡,确保操作效率。 3. `java.awt.tree.TreeModel`: - TreeModel是抽象类,定义了树数据模型的接口...

Global site tag (gtag.js) - Google Analytics