c# - 算法创建层次结构下拉

Question

我正在创建一个动态 HTML 部门，它根据从数据库接收到的值将内容作为层次结构进行下拉。我将根据我从数据库收到的值给出一个例子。结果集

ID  Name  ParentID
7   A      2
8   B      7
9   C      7
10  D      7
11  E      2
12  F      2
14  G      7

为此生成的 Html 应该是

<ul>
   <li> A 
        <ul>
            <li>B</li>
            <li>C</li>
            <li>D</li>
            <li>G</li>
       </ul>

   </li>
   <li>E</li>
   <li>F</li>
</ul>

有人可以建议实现这种结果的算法吗？提前致谢。

Answer 1

我用 Java 写了一段代码，但我认为你写 C# 代码不会有问题。你可以测试我的代码here .这个想法是将您的结果集映射到由下一个类表示的层次结构上。

节点类:

class Node {
    private String name;
    private List<Node> children;

    Node(String name) {
        this.name = name;
        children = new ArrayList<>();
    }

    void addChild(Node child) {
        children.add(child);
    }

    List<Node> getChildren() {
        return children;
    }

    public String toString() {
        return this.name;
    }
}

一些辅助类只是为了干净的代码:

class Tag {
    private String open;
    private String close;

    Tag(String open, String close) {
        this.open = open;
        this.close = close;
    }

    String open() {
        return open;
    }

    String close() {
        return close;
    }
}

层级模拟(我还添加了额外的层次用于演示):

private static List<Node> createHierarchy() {
    List<Node> nodes = new ArrayList<>();
    Node nodeA = new Node("A");
    Node nodeB = new Node("B");
    Node nodeC = new Node("C");
    Node nodeD = new Node("D");
    Node nodeE = new Node("E");
    Node nodeF = new Node("F");
    Node nodeG = new Node("G");
    Node node1 = new Node("1");
    Node node2 = new Node("2");
    Node node3 = new Node("3");
    Node node4 = new Node("4");
    nodeA.addChild(nodeB);
    nodeA.addChild(nodeC);
    nodeD.addChild(node1);
    nodeD.addChild(node2);
    node2.addChild(node3);
    node2.addChild(node4);
    nodeA.addChild(nodeD);
    nodeA.addChild(nodeE);
    nodes.add(nodeA);
    nodes.add(nodeF);
    nodes.add(nodeG);
    return nodes;
}

还有一个主逻辑。我使用递归来遍历我的数据结构:

public static void main(String[] args) {
    printHierarchy(createHierarchy(), new StringBuilder());
}

private static void printHierarchy(List<Node> nodes, StringBuilder stringBuilder) {
    stringBuilder.append(ul.open());
    for (Node node : nodes) {
        printNode(node, stringBuilder);
        printChildren(node.getChildren(), stringBuilder);
        stringBuilder.append(li.close());
    }
    stringBuilder.append(ul.close());
    System.out.print(stringBuilder.toString());
}

private static void printNode(Node node, StringBuilder stringBuilder) {
    stringBuilder.append(li.open()).append(node);
}

private static void printChildren(List<Node> children, StringBuilder stringBuilder) {
    if (children.size() == 0) {
        return;
    }
    stringBuilder.append(ul.open());
    for (Node child : children) {
        stringBuilder.append(li.open()).append(child);
        if (child.getChildren().size() > 0) {
            printChildren(child.getChildren(), stringBuilder);
        }
        stringBuilder.append(li.close());
    }
    stringBuilder.append(ul.close());
}

结果:

<ul>
  <li>A
    <ul>
      <li>B</li>
      <li>C</li>
      <li>D
        <ul>
          <li>1</li>
          <li>2
            <ul>
              <li>3</li>
              <li>4</li>
            </ul>
          </li>
        </ul>
      </li>
      <li>E</li>
    </ul>
  </li>
  <li>F</li>
  <li>G</li>
</ul>