使用遞迴實現，每次列印子節點前，都要把前面的“|”和空格打印出來，程式碼如下： 

typedef struct Node {
    char *name;
    int num;                  // 子節點數量
    struct Node **children;   // 子節點
} NodeT;

void PrintTree(char *gap, Node *node)
{
    printf("%s\n", node->name);
    if (node->children == NULL) {
        return;
    }
    char *newGap = malloc(strlen(gap) + sizeof("     "));
    for (int i = node->num - 1; i >= 0; i--) {
        printf("%s", gap);
        if (i == 0) {
            printf("└——— ");   // 列印最後一個節點時用“直角”
            sprintf(newGap, "%s     ", gap);  // 若最後一個節點有子節點，需要將gap增加空格
        } else {
            printf("|——— ");   // 列印中間節點時用“T形”
            sprintf(newGap, "%s|    ", gap);  // 若中間節點有子節點，需要將gap增加"|"和空格，增加的”|“是為了列印後面的節點
        }
        PrintTree(newGap, node->children[i]);
    }
}

 

int main(void)
{
　　char *gap = malloc(sizeof('\0'));
　　memset(gap, '\0', sizeof(' '));
　　*gap = '\0';

　　NodeT *node8 = malloc(sizeof(NodeT));
　　node8->name = malloc(sizeof('i'));
　　memset(node8->name, '\0', sizeof('i'));
　　node8->name[0] = 'i';
　　node8->num = 0;
　　node8->children = NULL;

　　NodeT **children4 = malloc(sizeof(NodeT *) * 1);
　　memset(children4, '\0', sizeof(NodeT *));
　　children4[0] = node8;

　　NodeT *node7 = malloc(sizeof(NodeT));
　　node7->name = malloc(sizeof('h'));
　　memset(node7->name, '\0', sizeof('h'));
　　node7->name[0] = 'h';
　　node7->num = 0;
　　node7->children = NULL;

　　NodeT *node6 = malloc(sizeof(NodeT));
　　node6->name = malloc(sizeof('g'));
　　memset(node6->name, '\0', sizeof('g'));
　　node6->name[0] = 'g';
　　node6->num = 0;
　　node6->children = NULL;

　　NodeT **children3 = malloc(sizeof(NodeT *) * 2);
　　memset(children3, '\0', sizeof(NodeT *));
　　children3[0] = node6;
　　children3[1] = node7;

　　NodeT *node5 = malloc(sizeof(NodeT));
　　node5->name = malloc(sizeof('f'));
　　memset(node5->name, '\0', sizeof('f'));
　　node5->name[0] = 'f';
　　node5->num = 0;
　　node5->children = NULL;

　　NodeT *node4 = malloc(sizeof(NodeT));
　　node4->name = malloc(sizeof('e'));
　　memset(node4->name, '\0', sizeof('e'));
　　node4->name[0] = 'e';
　　node4->num = 1;
　　node4->children = children4;

　　NodeT *node3 = malloc(sizeof(NodeT));
　　node3->name = malloc(sizeof('d'));
　　memset(node3->name, '\0', sizeof('d'));
　　node3->name[0] = 'd';
　　node3->num = 0;
　　node3->children = NULL;

　　NodeT **children2 = malloc(sizeof(NodeT *) * 3);
　　memset(children2, '\0', sizeof(NodeT *));
　　children2[0] = node3;
　　children2[1] = node4;
　　children2[2] = node5;

　　NodeT *node1 = malloc(sizeof(NodeT));
　　node1->name = malloc(sizeof('b'));
　　memset(node1->name, '\0', sizeof('b'));
　　node1->name[0] = 'b';
　　node1->num = 2;
　　node1->children = children3;

　　NodeT *node2 = malloc(sizeof(NodeT));
　　node2->name = malloc(sizeof('c'));
　　memset(node2->name, '\0', sizeof('c'));
　　node2->name[0] = 'c';
　　node2->num = 3;
　　node2->children = children2;

　　NodeT **children1 = malloc(sizeof(NodeT *) * 2);
　　memset(children1, '\0', sizeof(NodeT *));
　　children1[0] = node1;
　　children1[1] = node2;

　　NodeT *node = malloc(sizeof(NodeT));
　　node->name = malloc(sizeof('a'));
　　memset(node->name, '\0', sizeof('a'));
　　node->name[0] = 'a';
　　node->num = 2;
　　node->children = children1;

　　PrintTree(gap, node);

　　return 0;
}