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();

}

}

javaweb里面树形结构（tree）

这个是java中的forEach循环，和

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

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

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

树节点类：

package cn点抗 .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点抗 .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点抗 .tree.Node;  

import cn点抗 .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());  

}  

}

分享名称：javatree代码 javatreemap
网页网址：http://chengdu.cdxwcx.cn/article/ddsiegs.html