多叉树的实例

2019独角兽企业重金招聘Python工程师标准>>>

package com.demo.test;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

/**
 * 构造虚拟的层次数据
 */
class VirtualDataGenerator {
    // 构造无序的结果集列表，实际应用中，该数据应该从数据库中查询获得；
    public static List<Map<String,String>> getVirtualResult() {
        
        List<Map<String,String>> dataList = new ArrayList<Map<String,String>>();

        HashMap<String,String> dataRecord1 = new HashMap<String,String>();
        dataRecord1.put("id", "112000");
        dataRecord1.put("text", "廊坊银行解放道支行");
        dataRecord1.put("parentId", "110000");

        HashMap<String,String> dataRecord2 = new HashMap<String,String>();
        dataRecord2.put("id", "112200");
        dataRecord2.put("text", "廊坊银行三大街支行");
        dataRecord2.put("parentId", "112000");

        HashMap<String,String> dataRecord3 = new HashMap<String,String>();
        dataRecord3.put("id", "112100");
        dataRecord3.put("text", "廊坊银行广阳道支行");
        dataRecord3.put("parentId", "112000");

        HashMap<String,String> dataRecord4 = new HashMap<String,String>();
        dataRecord4.put("id", "113000");
        dataRecord4.put("text", "廊坊银行开发区支行");
        dataRecord4.put("parentId", "110000");

        HashMap<String,String> dataRecord5 = new HashMap<String,String>();
        dataRecord5.put("id", "100000");
        dataRecord5.put("text", "廊坊银行总行");
        dataRecord5.put("parentId", "");

        HashMap<String,String> dataRecord6 = new HashMap<String,String>();
        dataRecord6.put("id", "110000");
        dataRecord6.put("text", "廊坊分行");
        dataRecord6.put("parentId", "100000");

        HashMap<String,String> dataRecord7 = new HashMap<String,String>();
        dataRecord7.put("id", "111000");
        dataRecord7.put("text", "廊坊银行金光道支行");
        dataRecord7.put("parentId", "110000");

        dataList.add(dataRecord1);
        dataList.add(dataRecord2);
        dataList.add(dataRecord3);
        dataList.add(dataRecord4);
        dataList.add(dataRecord5);
        dataList.add(dataRecord6);
        dataList.add(dataRecord7);

        return dataList;
    }
    
    public static void main(String[] args) {
        List<Map<String, String>> virtualResult = getVirtualResult();
        Iterator<Map<String, String>> iterator = virtualResult.iterator();
    }
}

package com.demo.test;

import java.util.Comparator;

/**
 * 节点比较器
 */
class NodeIDComparator implements Comparator<Node> {
    // 按照节点编号比较
    public int compare(Node o1, Node o2) {
        int j1 = Integer.parseInt(o1.id);
        int j2 = Integer.parseInt(o2.id);
        
        /*
         *  j1  小于  j2   取   -1
         *  j1  等于  j2   取     0 
         *  j1  大于  j2   取     1
         */
        return (j1 < j2 ? -1 : (j1 == j2 ? 0 : 1));
    }
}

package com.demo.test;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

/**
 * 节点类
 */
class Node {
    /**
     * 节点编号
     */
    public String id;

    /**
     * 节点内容
     */
    public String text;

    /**
     * 父节点编号
     */
    public String parentId;

    /**
     * 孩子节点列表
     */
    private List<Node> children = new ArrayList<Node>();

    // 添加孩子节点
    public void addChild(Node node) {
        children.add(node);
    }

    // 先序遍历，拼接JSON字符串
    public String toString() {
        String result = "{" + "id : '" + id + "'" + ", text : '" + text + "'";
        if (children.size() != 0) {
            result += ", children : [";
            for (int i = 0; i < children.size(); i++) {
                result +=  children.get(i).toString() + ",";
            }
            result = result.substring(0, result.length() - 1);
            result += "]";
        } else {
            result += ", leaf : true";
        }
        return result + "}";
    }

    // 兄弟节点横向排序
    public void sortChildren() {
        if (children.size() != 0) {
            // 对本层节点进行排序（可根据不同的排序属性，传入不同的比较器，这里 传入ID比较器）
            Collections.sort(children, new NodeIDComparator());
            // 对每个节点的下一层节点进行排序
            for (int i = 0; i < children.size(); i++) {
                children.get(i).sortChildren();
            }
        }
    }
}

package com.demo.test;

import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
/*
 * 问题及解决方式
    现在可以把问题概括为：
    　　1、把数据库中的层次数据转换成多级树形结构的JSON格式的字符串;
    　　2、对树中每一个层次的节点按照某一属性（比如分支机构编号）进行排序;
    
    下面介绍解决问题的思路：
    　　        在数据结构这门课中，我们都学过树，无限级树形结构就可以抽象成一种多叉树结构，即每个节点下包含多个子节点的树形结构，
        首先就需要把数据库中的层次数据转换成多叉树结构的对象树，也就是构造出一棵多叉树。
        (数据库中存储的是层次的数据)
    有了数据结构，还要实现相应的算法，我们需要实现两种算法：
    　　1、兄弟节点横向排序算法，对隶属于同一个父节点下面的所有直接子节点按照某一节点属性和规则进行排序，保持兄弟节点横向有序；
    　　2、先序遍历算法，递归打印出无限级JSON字符串。
    
    方法总结
    概括起来分为三步：
    　　1、构造无序的多叉树结构
    　　2、实现兄弟节点横向排序方法
    　　3、实现先序遍历方法，打印出JSON字符串
 * 
 */
public class Tree {

    public static void main(String[] args) {
        // 读取层次数据结果集列表
        List<Map<String,String>> dataList = VirtualDataGenerator.getVirtualResult();

        // 节点列表（映射表，用于临时存储节点对象）
        HashMap<String,Node> nodeList = new HashMap<String,Node>();
        // 根节点
        Node root = null;
        // 将结果集存入映射表（后面将借助映射表构造多叉树）
        for (Iterator<Map<String, String>> it = dataList.iterator(); it.hasNext();) {
            Map<String, String> dataRecord = it.next();
            Node node = new Node();
            node.id = (String) dataRecord.get("id");
            node.text = (String) dataRecord.get("text");
            node.parentId = (String) dataRecord.get("parentId");
            nodeList.put(node.id, node);
        }
        // 构造无序的多叉树
        Set<Entry<String, Node>> entrySet = nodeList.entrySet();
        for (Iterator<Entry<String, Node>> it = entrySet.iterator(); it.hasNext();) {
            Node node = (Node) it.next().getValue();
            if (node.parentId == null || node.parentId.equals("")) {
                root = node;
            } else {
                (nodeList.get(node.parentId)).addChild(node);
            }
        }
        // 输出无序的树形结构的JSON字符串
        System.out.println(root.toString());
        // 对多叉树进行横向排序
        root.sortChildren();
        // 输出有序的树形结构的JSON字符串
        System.out.println(root.toString());
        
    }

}

转载于:https://my.oschina.net/Sheamus/blog/638632