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++){…}

還是有點區別的。有問題可以繼續 問。