树

import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Random;
public class Tree {
    private int id;
    private Tree parent; // 上级节点，无上级节点为null
    private String title; // 标题
    // 是否叶子节点，有子节点为false，无子节点为true，不是必要的，只是提供另外一种思路
    private boolean leaf;
    private int grade; // 层次
    public Tree() {}
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public Tree getParent() {
        return parent;
    }
    public void setParent(Tree parent) {
        this.parent = parent;
    }
    public String getTitle() {
        return title;
    }
    public void setTitle(String title) {
        this.title = title;
    }
    public boolean isLeaf() {
        return leaf;
    }
    public void setLeaf(boolean leaf) {
        this.leaf = leaf;
    }
    public int getGrade() {
        return grade;
    }
    public void setGrade(int grade) {
        this.grade = grade;
    }
    public void print() {
        StringBuffer buffer = new StringBuffer();
        // 这里纯粹为了打印出来能对齐...
        buffer.append(id < 10 ? "0" + id : id);
        buffer.append(':').append((parent == null ? "00" : parent.getId() < 10 ? "0" + parent.getId() : parent.getId()));
        buffer.append(':').append(title);
        buffer.append(':').append(leaf ? leaf + " " : leaf);
        buffer.append(':').append(grade);
        System.out.println(buffer.toString());
    }
    /**
     * 获取当前节点的层次，使用递归在树中扫描，顶级节点时返回
     *
     * @param treeMap
     * @param tree
     * @param grade
     * @return
     */
    private static int getGrade(Map<Integer, Tree> treeMap, Tree tree, int grade) {
        int result = grade;
        if (tree.getParent() != null) {
            // 如果上级节点不为null，说明上级节点不是子节点
            tree.getParent().setLeaf(false);
            return getGrade(treeMap, tree.getParent(), grade + 1);
        }
        return result;
    }
    /**
     * 初始化，每次初始化10个
     *
     * @param treeMap
     * @param i
     */
    private static void initMap(Map<Integer, Tree> treeMap, int i) {
        for (int k = (i - 1) * 10 + 1, j = i * 10 + 1; k < j; k++) {
            Tree tree = new Tree();
            tree.setId(k);
            int parent = 0;
            if (i - 1 != 0) {
                // 随机生成一个父节点，范围由传入的i决定，主要是为了确保父节点已在Map中
                parent = new Random().nextInt((i - 1) * 10);
            }
            if (parent == 0) {
                tree.setParent(null);
            } else {
                tree.setParent(treeMap.get(parent));
            }
            // 这里也是纯粹为了好看...
            tree.setTitle("Tree " + (k < 10 ? "0" + k : k));
            tree.setLeaf(true); // 默认为true，获取等级时会对该属性的值进行重新设置
            tree.setGrade(getGrade(treeMap, tree, 0));
            treeMap.put(k, tree);
        }
    }
    private static String gradeString(int grade) {
        String result = "";
        for (int i = 0; i < grade; i++) {
            result += "--";
        }
        return result;
    }
    /**
     * 输出树结构，也是使用递归扫描，外加一个循环扫描整个Map
     *
     * @param treeMap
     * @param parent
     * @param grade
     */
    private static void tree(Map<Integer, Tree> treeMap, Tree parent, int grade) {
        for (int i : treeMap.keySet()) {
            Tree tree = treeMap.get(i);
            if (tree.getParent() == parent) {
                System.out.println(gradeString(grade) + tree.getTitle());
                tree(treeMap, tree, grade + 1);
            }
        }
    }
    /**
     * @param args
     */
    public static void main(String[] args) {
        Map<Integer, Tree> treeMap = new LinkedHashMap<Integer, Tree>(); // 存储树结构
        // 初始化50个节点
        for (int i = 1; i < 6; i++) {
            initMap(treeMap, i);
        }
        tree(treeMap, null, 0);
        System.out.println("********************");
        for (int key : treeMap.keySet()) {
            treeMap.get(key).print();
        }
    }
}