一个树形结构的断层处理问题

有这样一些组织代码
code：001 001.001 001.002 001.001.001 001.002.001
或者是：001 001.002 001.003 001.004.001
或者是： 001 001.001 001.002.001 001.003.002 001.003.002.003 001.001.004.001
001是根节点，用.分割层次

如果是理想情况，如第一种，用递归很容易形成一棵树

001
    001.001
           001.001.001
   001.002
            001.002.001   

但是现在需要兼容其他情况，也就是如果没有找到父节点，就继续往上找，直到最后挂在根节点下
比如第二种情况就应该是

001
    001.002
    001.003
    001.004.001

第三种情况就应该是

001
    001.001
          001.001.004.001
    001.002.001
    001.003.002
          001.003.002.003
   

请问这种算法应该怎么写

该回答引用ChatGPT-3.5，仅供参考，不保证完全正确

实现这种树形结构的断层处理算法可以使用递归来解决。下面是一个使用Java编写的示例代码，可以根据给定的组织代码构建一个树形结构：

import java.util.HashMap;
import java.util.Map;

public class TreeBuilder {
    private TreeNode root;

    public TreeNode buildTree(String[] codes) {
        root = new TreeNode("001");
        Map<String, TreeNode> nodeMap = new HashMap<>();
        nodeMap.put(root.getCode(), root);

        for (String code : codes) {
            String[] parts = code.split("\\.");
            String parentCode = getParentCode(parts);

            TreeNode node = new TreeNode(code);
            TreeNode parent = nodeMap.get(parentCode);

            if (parent != null) {
                parent.addChild(node);
            } else {
                root.addChild(node);
            }

            nodeMap.put(code, node);
        }

        return root;
    }

    private String getParentCode(String[] parts) {
        StringBuilder parentCode = new StringBuilder();

        for (int i = 0; i < parts.length - 1; i++) {
            parentCode.append(parts[i]);

            if (i < parts.length - 2) {
                parentCode.append(".");
            }
        }

        return parentCode.toString();
    }

    public void printTree(TreeNode node) {
        printTree(node, 0);
    }

    private void printTree(TreeNode node, int level) {
        StringBuilder indent = new StringBuilder();
        for (int i = 0; i < level; i++) {
            indent.append("    ");
        }

        System.out.println(indent + node.getCode());
        for (TreeNode child : node.getChildren()) {
            printTree(child, level + 1);
        }
    }

    public static void main(String[] args) {
        String[] codes = {"001", "001.001", "001.002", "001.001.001", "001.002.001"};
        TreeBuilder treeBuilder = new TreeBuilder();
        TreeNode root = treeBuilder.buildTree(codes);
        treeBuilder.printTree(root);
    }
}

class TreeNode {
    private String code;
    private List<TreeNode> children;

    public TreeNode(String code) {
        this.code = code;
        this.children = new ArrayList<>();
    }

    public String getCode() {
        return code;
    }

    public List<TreeNode> getChildren() {
        return children;
    }

    public void addChild(TreeNode child) {
        children.add(child);
    }
}

这个示例代码首先创建了一个根节点，并使用一个Map来存储节点对象，以便根据代码快速查找对应的节点。然后，遍历给定的组织代码，将每个代码分割成层次结构，并根据父节点的存在与否将节点添加到相应的位置。如果找不到父节点，则将节点添加到根节点下。

最后，使用printTree方法打印整个树形结构，以验证结果。

你可以根据需要修改示例代码，添加更多的功能或适应特定的业务需求。希望这可以帮助到你！

public class TreeBuilder
{
    private TreeNode root;


    public TreeNode buildTree(String[] codes) {
        root = new TreeNode("001");
        Map<String, TreeNode> nodeMap = new HashMap<>();
        nodeMap.put(root.getCode(), root);

        for (String code : codes) {
            String[] parts = code.split("\\.");
            String parentCode = getParentCode(parts);

            TreeNode node = new TreeNode(code);
            TreeNode parent = nodeMap.get(parentCode);

            if (parent != null) {
                parent.addChild(node);
            } else {
                TreeNode parent2 = null;
                while (parentCode.split("\\.") != null || parentCode.split("\\.").length > 0)
                {
                    String[] parts2 = parentCode.split("\\.");
                    parentCode = getParentCode(parts2);
                    TreeNode node2 = new TreeNode(code);
                    parent2 = nodeMap.get(parentCode);
                    if (parent2 != null)
                    {
                        parent2.addChild(node);
                        break;
                    }
                }
                if(parent2 == null)
                {
                    root.addChild(node);
                }
            }

            nodeMap.put(code, node);
        }

        return root;
    }

    private String getParentCode(String[] parts) {
        StringBuilder parentCode = new StringBuilder();

        for (int i = 0; i < parts.length - 1; i++) {
            parentCode.append(parts[i]);

            if (i < parts.length - 2) {
                parentCode.append(".");
            }
        }

        return parentCode.toString();
    }

    public void printTree(TreeNode node) {
        printTree(node, 0);
    }

    private void printTree(TreeNode node, int level) {
        StringBuilder indent = new StringBuilder();
        for (int i = 0; i < level; i++) {
            indent.append("    ");
        }

        System.out.println(indent + node.getCode());
        for (TreeNode child : node.getChildren()) {
            printTree(child, level + 1);
        }
    }

    public static void main(String[] args) {
//        String[] codes = {"001.001", "001.002","001.003", "001.003.001", "001.004.001","001.003.002.001",};
//        String[] codes = {"001.001", "001.002.001", "001.003.002", "001.003.002.003", "001.001.004.001"};
        String[] codes = {"001.001", "001.001.004.001"};
        TreeBuilder treeBuilder = new TreeBuilder();
        TreeNode root = treeBuilder.buildTree(codes);
        treeBuilder.printTree(root);
    }

}