java的树_用java实现二叉树

Ⅰ 用java实现二叉树

我有很多个(假设10万个)数据要保存起来，以后还需要从保存的这些数据中检索是否存在某
个数据，（我想说出二叉树的好处，该怎么说呢？那就是说别人的缺点），假如存在数组中，
那么，碰巧要找的数字位于99999那个地方，那查找的速度将很慢，因为要从第1个依次往
后取，取出来后进行比较。平衡二叉树（构建平衡二叉树需要先排序，我们这里就不作考虑
了）可以很好地解决这个问题，但二叉树的遍历（前序，中序，后序）效率要比数组低很多，
public class Node {
public int value;
public Node left;
public Node right;
public void store(intvalue)
right.value=value;
}
else
{
right.store(value);
}
}
}
public boolean find(intvalue)
{
System.out.println("happen" +this.value);
if(value ==this.value)
{
return true;
}
else if(value>this.value)
{
if(right ==null)returnfalse;
return right.find(value);
}else
{
if(left ==null)returnfalse;
return left.find(value);
}
}
public void preList()
{
System.out.print(this.value+ ",");
if(left!=null)left.preList();
if(right!=null) right.preList();
}
public void middleList()
{
if(left!=null)left.preList();
System.out.print(this.value+ ",");
if(right!=null)right.preList();
}
public void afterList()
{
if(left!=null)left.preList();
if(right!=null)right.preList();
System.out.print(this.value+ ",");
}
public static voidmain(String [] args)
{
int [] data =new int[20];
for(inti=0;i<data.length;i++)
{
data[i] = (int)(Math.random()*100)+ 1;
System.out.print(data[i] +",");
}
System.out.println();
Node root = new Node();
root.value = data[0];
for(inti=1;i<data.length;i++)
{
root.store(data[i]);
}
root.find(data[19]);
root.preList();
System.out.println();
root.middleList();
System.out.println();
root.afterList();
}
}

Ⅱ 树在java中的应用有哪些

首先：树与线性表、栈、队列等线性结构不同，树是一种非线性结构。一棵树只有一个根节点，如果一棵树有了多个根节点，那它已经不再是一棵树了，而是多棵树的集合，也被称为森林。
其次：java中树的应用主要有：菜单树，还有权限树，商品分类列表也是树结构。

Ⅲ java中的树

swing里有JTree啊，好多实现类
web版本里也有很多现成的js 如 dtree

Ⅳ java中如何建立一个java树，请详解

importjava.awt.*;
importjavax.swing.*;
classTreeDemoextendsJFrame
{
	publicTreeDemo()
	{
		setSize(400,300);
		setTitle("演示怎样使用JTree");
		show();
		JScrollPanejPanel=newJScrollPane();
		getContentPane().add(jPanel);
		JTreejtree=newJTree();
		jPanel.getViewport().add(jtree,null);
		validate();
		setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
	}
}
publicclassExample5_25
{
	publicstaticvoidmain(String[]args)
	{
		TreeDemoframe=newTreeDemo();
	}
}

其中JScrollPane是一个带滚动条的面板类。

将对象加入到带滚动条的面板类中，在将已建的数放入到其中。

就可建立一个系统默认的树结构。

Ⅳ 如何用Java实现树形结构啊

定义一个简单的菜单类这里是简单的示例你可以自行扩展package entity;import java.util.ArrayList;
import java.util.List;/**
* 菜单类
* @author Administrator
*
*/
public class Menu {
/**
* 菜单标题
*/
private String title;
/**
* 子菜单的集合
*/
private List<Menu> childs;

/**
* 父菜单
*/
private Menu parent;

/**
* 构造函数初始化标题和子菜单集合
*/
public Menu(String title) {
this();
this.title=title;
}
/**
* 构造函数创建一个虚拟的父菜单(零级菜单) 所有的一级菜单都归属于一个虚拟的零级菜单
*
*/
public Menu() {
this.childs = new ArrayList<Menu>();
}
/**
* 获取子菜单
* @return
*/
public List<Menu> getChilds() {
return childs;
}
/**
* 获取标题
* @return
*/
public String getTitle() {
return title;
}
/**
* 获取父菜单
* @return
*/
public Menu getParent() {
return parent;
}
/**
* 添加子菜单并返回该子菜单对象
* @param child
* @return
*/
public Menu addChild(Menu child){
this.childs.add(child);
return child;
}
/**
* 设置父菜单
* @param parent
*/
public void setParent(Menu parent) {
this.parent = parent;
}
/**
* 设置标题
* @param title
*/
public void setTitle(String title) {
this.title = title;
}
} 测试package entity;
/**
* 测试类
* @author Administrator
*
*/
public class Test { /**
* @param args
*/
public static void main(String[] args) {
/**
* 创建一个虚拟的父菜单用于存放一级菜单 menu01 和 menu02
*/
Menu root = new Menu();
/**
* 创建两个一级菜单
*/
Menu menu01 = new Menu("一级菜单01");
Menu menu02 = new Menu("一级菜单02");
/**
* 加入虚拟菜单
*/
root.addChild(menu01);
root.addChild(menu02);
/**
* 为两个一级菜单分别添加两个子菜单并返回该子菜单需要进一步处理的时候才接收返回的对象否则只要调用方法
*/
Menu menu0101 = menu01.addChild(new Menu("二级菜单0101"));
menu01.addChild(new Menu("二级菜单0102"));
menu02.addChild(new Menu("二级菜单0201"));
Menu menu0202 = menu02.addChild(new Menu("二级菜单0202"));
/**
* 添加三级菜单
*/
menu0101.addChild(new Menu("三级菜单010101"));
menu0202.addChild(new Menu("三级菜单020201"));
/**
* 打印树形结构
*/
showMenu(root);
} /**
* 递归遍历某个菜单下的菜单树
*
* @param menu
* 根菜单
*/
private static void showMenu(Menu menu) {
for (Menu child : menu.getChilds()) {
showMenu(child, 0);
}
} private static void showMenu(Menu menu, int tabNum) {
for (int i = 0; i < tabNum; i++)
System.out.print("\t");
System.out.println(menu.getTitle());
for (Menu child : menu.getChilds())
// 递归调用
showMenu(child, tabNum + 1);
}}
控制台输出结果一级菜单01 二级菜单0101
三级菜单010101
二级菜单0102一级菜单02
二级菜单0201
二级菜单0202
三级菜单020201

Ⅵ java对象树是什么东东

给你这么讲吧:就相当于一个大家庭一样,首先是祖父母,外祖父母,然后是线面的父母,叔叔,阿姨等,再然后是表哥,表姐,堂兄堂弟等,再然后是下面的子子孙孙.等等.就如同一颗倒置的大树,根在上边,枝叶在下边一样,有若干分支.但不是无穷无尽的.能明白吗?

Ⅶ 关于java树结构的实现

可以用递归模拟树
要求子树拥有父树的id;
绝对原创;
import java.util.ArrayList;
import java.util.List;

public class Test2 {
public static void main(String[]args){
List<Tree> trees = new ArrayList<Tree>();
int id = 1;
Tree t1 = new Tree(0,id++,"我是根树");
Tree t2 = new Tree(0,id++,"我是第二个根树");
Tree t3 = new Tree(1,id++,"我是子树");
trees.add(t1);
trees.add(t2);
trees.add(t3);

Tree t4 = new Tree(1,id++,"树根你好");
Tree t5 = new Tree(4,id++,"我不是树根");
Tree t6 = new Tree(5,id++,"我才是树根");
trees.add(t4);
trees.add(t5);
trees.add(t6);

show(trees);
}

public static void show(List<Tree> trees){
for(int i=0;i<trees.size();i++){
Tree t = trees.get(i);
if(t.parent == 0){
StringBuffer blank = new StringBuffer();
t.show(trees,blank);
}
}
}
}

import java.util.List;

public class Tree {
public Tree(int parent,int id,String str) {
this.parent = parent;
this.id = id;
this.str = str;
}
int parent;//树的根树
int id;
String str;
// StringBuffer blank = new StringBuffer();
void show(List<Tree> trees, StringBuffer blank){
blank.append(" ");
System.out.println(blank + str );
for(int i=0;i<trees.size();i++){
Tree t = trees.get(i);
if(t.parent == id){
t.show(trees,blank);
}
}
}

}

Ⅷ Java中有没有现成的树形结构的类

树时用来存储东西的，如果非要说类似的类，那么应该是treemap和treeset应该是使用的avl平衡二叉树实现的。其他的，好像暂时没有发现。正常算法使用的树，都是用的node里面存放引用来实现的。

Ⅸ JAVA画树

画什么都行，这个你得自己实现。我可以给你写一个画树的小程序：

---------------------------------------------------------
//TreeNode.java

package util;

import java.util.Vector;

public class TreeNode {
private Vector<TreeNode> children;
private TreeNode parent;
private TreeNode root;

public TreeNode (TreeNode parent) {
children = new Vector<TreeNode>();
if (parent == null)
root = this;
else {
parent.addChild(this);
}
}

public void addChild (TreeNode n) {
addChild(children.size(), n);
}

public void addChild (int index, TreeNode n) {
children.add(index, n);
n.parent = this;
}

public void removeChild (TreeNode n) {
children.remove(n);
}

public void removeChild (int index) {
children.remove(index);
}

public void setChild (int index, TreeNode n) {
children.set(index, n);
n.parent = this;
}

public TreeNode getChild (int index) {
return children.get(index);
}

public void changePosition (int index1, int index2) {
if (0 <= index1 && index1 < children.size() &&
0 <= index2 && index2 <= children.size()) {
TreeNode tmp = children.get(index1);
children.set(index1, children.get(index2));
children.set(index2, tmp);
}
}

public void setParent (TreeNode n) {
parent = n;
}

public TreeNode getRoot () {
return root;
}

public TreeNode getParent () {
return parent;
}

public Vector<TreeNode> getChildren () {
return children;
}
}

------------------------------------------------------------
//TreePanelNode.java

package ui;

import util.TreeNode;
import java.awt.*;

public class TreePanelNode extends TreeNode {
private int x, y, width, height;
private Object value;
private TreePanelNode parent;

public TreePanelNode (TreePanelNode parent, int x, int y, int width, int height, Object value) {
super(parent);
this.x = x;
this.y = y;
this.parent = parent;
this.width = width;
this.height = height;
this.value = value;
}

public void setLocation (int x, int y) {
this.x = x;
this.y = y;
}

public void setSize (int width, int height) {
this.width = width;
this.height = height;
}

public Rectangle getBounds () {
return new Rectangle(x, y, width, height);
}

public Object getValue () {
return value;
}

public Point getLocation () {
return new Point(x, y);
}

public int getWidth () {
return width;
}

public int getHeight () {
return height;
}

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

public TreePanelNode getParent () {
return parent;
}
}

--------------------------------------------------------------
//TreePanel.java

package ui;

import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
import java.util.Vector;

public class TreePanel extends JPanel {
private Vector<TreePanelNode> nodes;
private Vector<Integer> selectedNodes;

private int tmpX, tmpY;
private int editingNode = -1;
private int addingParent = -2;
private int mouseX, mouseY;

public TreePanel () {
nodes = new Vector<TreePanelNode>();
selectedNodes = new Vector<Integer>();

setBackground(Color.WHITE);
addMouseListener(new MouseAdapter() {
public void mousePressed (MouseEvent me) {
tmpX = me.getX();
tmpY = me.getY();
if (nodes.size() == 0) {
addingParent = -1;
}
int i = 0;
for (; i<nodes.size(); i++) {
if (nodes.get(i).getBounds().contains(mouseX, mouseY)) {
if (me.isControlDown()) {
if (!selectedNodes.contains(i))
selectedNodes.add(i);
else
selectedNodes.removeElement(i);
} else if (!selectedNodes.contains(i)) {
selectedNodes = new Vector<Integer>();
selectedNodes.add(i);
}
if (me.getClickCount() == 2) {
nodes.get(i).setValue("");
editingNode = i;
}
break;
}
}
if (i == nodes.size())
if (!me.isControlDown())
selectedNodes = new Vector<Integer>();
repaint();
}

public void mouseReleased (MouseEvent me) {
addingParent = -2;
}
});
addMouseMotionListener(new MouseMotionAdapter() {
public void mouseDragged (MouseEvent me) {
mouseX = me.getX();
mouseY = me.getY();
int i = 0;
for (; i<selectedNodes.size(); i++) {
if (nodes.get(selectedNodes.get(i)).getBounds().contains(mouseX, mouseY))
break;
}
if (i != selectedNodes.size()) {
if (me.isAltDown() && addingParent != -3) {
addingParent = selectedNodes.get(i);
} else {
for (i=0; i<selectedNodes.size(); i++) {
nodes.get(selectedNodes.get(i)).setLocation(nodes.get(selectedNodes.get(i)).getLocation().x + mouseX - tmpX,
nodes.get(selectedNodes.get(i)).getLocation().y + mouseY - tmpY);
}
tmpX = mouseX;
tmpY = mouseY;
}
}
repaint();
}

public void mouseMoved (MouseEvent me) {
mouseX = me.getX();
mouseY = me.getY();
}
});
addKeyListener(new KeyAdapter() {
public void keyTyped (KeyEvent ke) {
if (editingNode != -1) {
if (ke.getKeyCode() == KeyEvent.VK_ENTER)
editingNode = -1;
else
nodes.get(editingNode).setValue(nodes.get(editingNode).getValue().toString()+ke.getKeyChar());
repaint();
}
}
});
}

public void paint (Graphics g) {
super.paint(g);
FontMetrics fm = g.getFontMetrics();
if (addingParent > -2) {
String str = "node" + nodes.size();
int width = fm.stringWidth(str);
int height = fm.getHeight();

TreePanelNode pnt = null;
if (addingParent != -1)
pnt = nodes.get(addingParent);

nodes.add(new TreePanelNode(pnt, mouseX-width/2-10, mouseY-height/2-20, width+20, height+40, str));
addingParent = -3;
selectedNodes = new Vector<Integer>();
selectedNodes.add(nodes.size()-1);
}
for (int i=0; i<nodes.size(); i++) {
String str = nodes.get(i).getValue().toString();
int width = fm.stringWidth(str);
int height = fm.getHeight();
nodes.get(i).setSize(width + 20, height + 40);

if (selectedNodes.contains(i))
g.setColor(Color.RED);
else
g.setColor(Color.BLACK);

if (nodes.get(i).getParent() != null)
g.drawLine(nodes.get(i).getLocation().x+nodes.get(i).getWidth()/2,
nodes.get(i).getLocation().y+nodes.get(i).getHeight()/2,
nodes.get(i).getParent().getLocation().x+nodes.get(i).getParent().getWidth()/2,
nodes.get(i).getParent().getLocation().y+nodes.get(i).getParent().getHeight()/2);

g.drawString(str, nodes.get(i).getLocation().x + 10, nodes.get(i).getLocation().y + 20);
g.drawRect(nodes.get(i).getLocation().x, nodes.get(i).getLocation().y, nodes.get(i).getWidth(), nodes.get(i).getHeight());
}
grabFocus();
}
}

----------------------------------------------------------
//MainView.java

package ui;

import javax.swing.*;

public class MainView extends JFrame {
private TreePanel tp;

public MainView () {
super("TreeDemo");
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setSize(800, 600);
setLocationRelativeTo(null);

tp = new TreePanel();
add(tp);
setVisible(true);
}

public static void main (String args[]) {
new MainView();
}
}

------------------------------------------------------------
好了。然后你新建一个 util 文件夹和一个 ui 文件夹，把第一个文件放在 util 文件夹下，把其余文件放在 ui 文件夹下，文件名都根据我的注释就行了。
例如你这两个文件夹新建在 D 盘下，在命令行中编译运行：

----------------------------------------------------------
...>D:

D:\>javac util\TreeNode.java ui\TreePanelNode.java ui\TreePanel.java ui\MainView.java

D:\>java ui.MainView

----------------------------------------------------------
于是便能看到效果。祝您好运，顺便我写了这么多就给个最佳答案吧，哈哈。
忘了告诉你，按住 Alt 键拖动 Node 可以添加子节点。
按住 Ctrl 键单击 node 可以多选。
双击一个 node 然后可以从键盘输入新的字符串，按回车结束。

----------------------------------------------------------
如果对以上的程序还有什么问题，留下邮箱，我直接发给你。

导航:首页 > 编程语言 > java的树

java的树

与java的树相关的资料