treejava的简单介绍

本文目录一览：

• 1、java（算法与数据结构）tree
• 2、如何在java构造函数中创建一棵树
• 3、java中的tree是什么意思
• 4、Java怎么实现输出是一个tree结构
• 5、javaweb里面树形结构（tree）

java（算法与数据结构）tree

代码实现[一]部分

package ChapterEight;

class Tree {

class Node {

public long value;

public Node leftChild;

public Node rightChild;

public Node(long value) {

this.value = value;

leftChild = null;

rightChild = null;

}

}

public Node root;

public Tree() {

root = null;

}

// 向树中插入一个节点

public void insert(long value) {

Node newNode = new Node(value);

// 树是空的

if (root == null)

root = newNode;

else {

Node current = root;

Node parentNode;

while (true) {

parentNode = current;

if (value current.value) {

current = current.leftChild;

// 要插入的节点为左孩子节点

if (current == null) {

parentNode.leftChild = newNode;

return;

}

} else {

// 要插入的节点为右孩子节点

current = current.rightChild;

if (current == null) {

parentNode.rightChild = newNode;

return;

}

}

}

}

}

// 先续遍历树中的所有节点

public void preOrder(Node currentRoot) {

if (currentRoot != null) {

System.out.print(currentRoot.value + ” “);

preOrder(currentRoot.leftChild);

preOrder(currentRoot.rightChild);

}

}

// 中续遍历树中的所有节点

public void inOrder(Node currentNode) {

if (currentNode != null) {

inOrder(currentNode.leftChild);

System.out.print(currentNode.value + ” “);

inOrder(currentNode.rightChild);

}

}

// 后续遍历树中的所有节点

public void postOrder(Node currentNode) {

if (currentNode != null) {

postOrder(currentNode.leftChild);

postOrder(currentNode.rightChild);

System.out.print(currentNode.value + ” “);

}

}

public void traverse(int traverseType) {

switch (traverseType) {

case 1:

preOrder(root);

break;

case 2:

inOrder(root);

break;

case 3:

postOrder(root);

break;

default:

break;

}

// 依据树节点的值删除树中的一个节点

public boolean delete(int value) {

// 遍历树过程中的当前节点

Node current = root;

// 要删除节点的父节点

Node parent = root;

// 记录树的节点为左孩子节点或右孩子节点

boolean isLeftChild = true;

while (current.value != value) {

parent = current;

// 要删除的节点在当前节点的左子树里

if (value current.value) {

isLeftChild = true;

current = current.leftChild;

}

// 要删除的节点在当前节点的右子树里

else {

isLeftChild = false;

current = current.rightChild;

}

// 在树中没有找到要删除的节点

if (current == null)

return false;

}

// 要删除的节点为叶子节点

if (current.leftChild == null current.rightChild == null) {

// 要删除的节点为根节点

if (current == root)

root = null;

// 要删除的节点为左孩子节点

else if (isLeftChild)

parent.leftChild = null;

// 要删除的节点为右孩子节点

else

parent.rightChild = null;

}

// 要删除的节点有左孩子节点，没有右孩子节点

else if (current.rightChild == null) {

// 要删除的节点为根节点

if (current == null)

root = current.leftChild;

// 要删除的节点为左孩子节点

else if (isLeftChild)

parent.leftChild = current.leftChild;

// 要删除的节点为右孩子节点

else

parent.rightChild = current.leftChild;

}

// 要删除的节点没有左孩子节点，有右孩子节点

else if (current.leftChild == null) {

// 要删除的节点为根节点

if (current == root)

root = root.rightChild;

// 要删除的节点为左孩子节点

else if (isLeftChild)

parent.leftChild = current.rightChild;

// 要删除的节点为右孩子节点

else

parent.rightChild = current.rightChild;

}

// 要删除的接节点既有左孩子节点又有右孩子节点

else {

Node successor = getSuccessor(current);

// 要删除的节点为根节点

if (current == root)

root = successor;

// 要删除的节点为左孩子节点

else if (isLeftChild)

parent.leftChild = successor;

// 要删除的节点为右孩子节点

else

parent.rightChild = successor;

}

return true;

}

// 找到要删除节点的替补节点

private Node getSuccessor(Node delNode) {

// 替补节点的父节点

Node successorParent = delNode;

// 删除节点的替补节点

Node successor = delNode;

Node current = delNode.rightChild;

while (current != null) {

// successorParent指向当前节点的上一个节点

successorParent = successor;

// successor变为当前节点

successor = current;

current = current.leftChild;

}

// 替补节点的右孩子节点不为空

if (successor != delNode.rightChild) {

successorParent.leftChild = successor.rightChild;

successor.rightChild = delNode.rightChild;

}

return successor;

}

}

public class TreeApp {

public static void main(String[] args) {

Tree tree = new Tree();

tree.insert(8);

tree.insert(50);

tree.insert(45);

tree.insert(21);

tree.insert(32);

tree.insert(18);

tree.insert(37);

tree.insert(64);

tree.insert(88);

tree.insert(5);

tree.insert(4);

tree.insert(7);

System.out.print(“PreOrder : “);

tree.traverse(1);

System.out.println();

System.out.print(“InOrder : “);

tree.traverse(2);

System.out.println();

System.out.print(“PostOrder : “);

tree.traverse(3);

System.out.println();

System.out.println(tree.delete(7));

System.out.print(“PreOrder : “);

tree.traverse(1);

System.out.println();

System.out.print(“InOrder : “);

tree.traverse(2);

System.out.println();

System.out.print(“PostOrder : “);

tree.traverse(3);

System.out.println();

}

}

如何在java构造函数中创建一棵树

import java.util.Stack;//导入栈包

public class newtree {

private newtree lchild;// 声明数据成员

private newtree rchild;

private char data;

private newtree root;

public newtree(newtree l, newtree r, char data) {// 有参构造函数进行成员赋值

lchild = l;

rchild = r;

this.data = data;

}

public newtree() {// 无参构造函数创建树

newtree f = new newtree(null, null, ‘f’);

newtree g = new newtree(null, null, ‘g’);

newtree d = new newtree(null, null, ‘d’);

newtree e = new newtree(null, null, ‘e’);

newtree b = new newtree(d, e, ‘b’);

newtree c = new newtree(f, g, ‘c’);

newtree a = new newtree(b, c, ‘a’);

this.root=a;

}

public void visit(newtree p) {/* 输出数据 */

System.out.print(p.data);// 访问结点

}

@SuppressWarnings(“unchecked”)

public void InOrder() {/* 输入数据 */

newtree p=this.root;//你建了一棵树要把根节点赋值进去啊

Stack s = new Stack();

while (p != null || !s.isEmpty()) /* 处理数据：进行中序遍历 */

{

if (p != null) {

s.push(p);

p = p.lchild;

} else {

p = (newtree) s.pop();

p.visit(p);//this指的是当前的类对象

p = p.rchild;

}

}

}

public static void main(String[] args) {

// TODO Auto-generated method stub

newtree h = new newtree();// 声明变量，变量赋值

h.InOrder();

}

}

//根据你的代码改了一个

import java.util.Stack;//导入栈包

public class newtree {

public Tree createTree() {// 无参构造函数创建树

Tree f = new Tree(null, null, ‘f’);

Tree g = new Tree(null, null, ‘g’);

Tree d = new Tree(null, null, ‘d’);

Tree e = new Tree(null, null, ‘e’);

Tree b = new Tree(d, e, ‘b’);

Tree c = new Tree(f, g, ‘c’);

Tree a = new Tree(b, c, ‘a’);

return a;

}

public void InOrder(Tree p) {/* 输入数据 */

StackTree s = new StackTree();

while (p != null || !s.isEmpty()) { /* 处理数据：进行中序遍历 */

if (p != null) {

s.push(p);

p = p.lchild;

} else {

p = s.pop();

System.out.print(p.data);

p = p.rchild;

}

}

}

public void inOrder1(Tree p) {

if (p == null)

return;

inOrder1(p.lchild);

System.out.print(p.data);

inOrder1(p.rchild);

}

public static void main(String[] args) {

newtree h = new newtree();// 声明变量，变量赋值

h.InOrder(h.createTree());

System.out.println();

h.inOrder1(h.createTree());

}

}

class Tree {

Tree lchild;// 声明数据成员

Tree rchild;

char data;

Tree(Tree lchild, Tree rchild, char data) {

this.lchild = lchild;

this.rchild = rchild;

this.data = data;

}

}

java中的tree是什么意思

树状结构，常用于菜单，或是文件管理等等具有层次关系的内容；

Java怎么实现输出是一个tree结构

树节点类：

package cn.com.tree;  

  

public class Node {  

    private Integer id;  

    private Integer parentId;  

    private String name;  

    private String link;  

      

    public Integer getId() {  

        return id;  

    }  

    public void setId(Integer id) {  

        this.id = id;  

    }  

    public Integer getParentId() {  

        return parentId;  

    }  

    public void setParentId(Integer parentId) {  

        this.parentId = parentId;  

    }  

    public String getName() {  

        return name;  

    }  

    public void setName(String name) {  

        this.name = name;  

    }  

    public String getLink() {  

        return link;  

    }  

    public void setLink(String link) {  

        this.link = link;  

    }  

}

输出树形菜单类：

package cn.com.tree;  

  

import java.util.ArrayList;  

import java.util.List;  

  

public class Tree {  

    private StringBuffer html = new StringBuffer();  

    private ListNode nodes;  

      

    public Tree(ListNode nodes){  

        this.nodes = nodes;  

    }  

      

    public String buildTree(){  

        html.append(“ul”);  

        for (Node node : nodes) {  

            Integer id = node.getId();  

            if (node.getParentId() == null) {  

                html.append(“\r\nli id='” + id + “‘” + node.getName()+ “/li”);  

                build(node);  

            }  

        }  

        html.append(“\r\n/ul”);  

        return html.toString();  

    }  

      

    private void build(Node node){  

        ListNode children = getChildren(node);  

        if (!children.isEmpty()) {  

            html.append(“\r\nul”);  

            for (Node child : children) {  

                Integer id = child.getId();  

                html.append(“\r\nli id='” + id + “‘” + child.getName()+ “/li”);  

                build(child);  

            }  

            html.append(“\r\n/ul”);  

        }   

    }  

      

    private ListNode getChildren(Node node){  

        ListNode children = new ArrayListNode();  

        Integer id = node.getId();  

        for (Node child : nodes) {  

            if (id.equals(child.getParentId())) {  

                children.add(child);  

            }  

        }  

        return children;  

    }  

}

测试类：

package zzj.test;  

  

import java.util.ArrayList;  

import java.util.List;  

  

import cn.com.tree.Node;  

import cn.com.tree.Tree;  

  

  

public class Test {  

  

    /** 

     * @param args 

     */  

    public static void main(String[] args) {  

        ListNode nodes = new ArrayListNode();  

          

        Node node1 = new Node();  

        node1.setId(1);  

        node1.setName(“node1”);  

        node1.setParentId(null);  

        node1.setLink(null);  

        nodes.add(node1);  

          

        Node node11 = new Node();  

        node11.setId(11);  

        node11.setName(“node11”);  

        node11.setParentId(1);  

        node11.setLink(null);  

        nodes.add(node11);  

          

        Node node111 = new Node();  

        node111.setId(111);  

        node111.setName(“node111”);  

        node111.setParentId(11);  

        node111.setLink(null);  

        nodes.add(node111);  

          

        Node node12 = new Node();  

        node12.setId(12);  

        node12.setName(“node12”);  

        node12.setParentId(1);  

        node12.setLink(null);  

        nodes.add(node12);  

          

        Node node2 = new Node();  

        node2.setId(2);  

        node2.setName(“node2”);  

        node2.setParentId(null);  

        node2.setLink(null);  

        nodes.add(node2);  

          

        Node node21 = new Node();  

        node21.setId(21);  

        node21.setName(“node21”);  

        node21.setParentId(2);  

        node21.setLink(null);  

        nodes.add(node21);  

          

        Node node3 = new Node();  

        node3.setId(3);  

        node3.setName(“node3”);  

        node3.setParentId(null);  

        node3.setLink(null);  

        nodes.add(node3);  

          

        Tree tree = new Tree(nodes);  

        System.out.println(tree.buildTree());  

    }  

}

javaweb里面树形结构（tree）

这个是java中的forEach循环，和

for(int i =0 ;i  10 ;i++){…}

还是有点区别的。有问题可以继续 问。