Algorithmus zum Erstellen von Hierarchie Drop-down

Question

Ich erstellen eine dynamische HTML-Abteilung, die Drop-Down-Inhalt als eine Hierarchie basierend auf Wert aus der Datenbank erhalten hat. Ich werde ein Beispiel geben, basierend auf dem Wert, den ich von der Datenbank erhalte. Ergbnisssatzes

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

Zu diesem generierten HTML sollte

<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> 

sein Kann jemand Algorithmus vorschlagen, diese Art von Ergebnis zu erzielen. Danke im Voraus.

Answer 1

Ich habe einen Code in Java geschrieben, aber ich denke, dass es kein Problem für Sie sein wird, den C# -Code zu schreiben. Sie können meinen Code here testen. Die Idee besteht darin, die Ergebnismenge einer Hierarchie zuzuordnen, die durch die nächsten Klassen repräsentiert wird.

Node-Klasse:

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; 
    } 
} 

Einige Helfer Klasse nur aus Gründen der sauberen Code:

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; 
    } 
} 

Hierarchy-Emulation (I auch zusätzliche Ebenen zur Demonstration hinzugefügt):

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; 
} 

Und eine Hauptlogik. Früher habe ich eine Rekursion auf meine Datenstruktur durchqueren:

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()); 
} 

Ergebnis:

<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> 

Answer 2

Beginnen Sie mit ParentID = null.

Erhalten Sie alle Elemente, bei denen ParentID mit Ihrer ParentID übereinstimmt, und prüfen Sie, ob mehr als ein Element für die nächste Unterebene vorhanden ist. Wenn ja, wickle sie in ein -Tag.

Dann durchlaufen Sie alle Elemente, die Sie haben, hängen Sie das Element an und behandeln Sie ihre Unterebenen rekursiv.

Sie erreichen einen Endknoten, wenn Sie keine weiteren Elemente erhalten, die Ihrer ParentID entsprechen.

Vergessen Sie auch nicht, Ihre geöffneten -Tags zu schließen.