duangsuse::Echo

如果有人买了（当然是不可能的，因为没有编译原理的 dalao 关注我？233333）《深入分析 GCC》这本书，会发现作者写了很多 AWK/sed/GNU bc/Bash 代码辅助分析（其实还用了 Graphviz）...

看到 188 面有一些代码可以生成这种树结构，抄下来看看： #c #linux #share #book #pl
（我修改了一些标识符语义上的错误，格式化了代码，增强了代码语义的易读性）

#include "gt-passes.h"

char *pass_type_names[] = {"GIMPLE_PASS", "RTL_PASS", "SIMPLE_IPA_PASS", "IPA_PASS"};

void dump_opt_pass(FILE *fp, struct opt_pass *pass, int indent) {
  int i; struct opt_pass *p = pass;

  while (p != NULL) {
    for (i = 0; i < indent; i++) {
      if (i % 4 == 0) fprintf(fp, "|");
      else if (i == indent - 1) fprintf(fp, ">");
      else if (i == indent - 2) fprintf(fp, "-");
      else if (i == indent - 3) fprintf(fp, "-");
      else fprintf(fp, " ");
    }
    fprintf(fp, "  %-16s [%s]\n", p->name, pass_type_names[p->type]);

    if (p->sub != NULL) dump_opt_pass(fp, p->sub, indent + 4);
    p = p->next;
  }
}

30 viewsduangsuse ¯\_(ツ)_/¯ |学渣|母上千古, 09:20

duangsuse::Echo

如果有人买了（当然是不可能的，因为没有编译原理的 dalao 关注我？233333）《深入分析 GCC》这本书，会发现作者写了很多 AWK/sed/GNU bc/Bash 代码辅助分析（其实还用了 Graphviz）... 看到 188 面有一些代码可以生成这种树结构，抄下来看看： #c #linux #share #book #pl （我修改了一些标识符语义上的错误，格式化了代码，增强了代码语义的易读性） #include "gt-passes.h" char *pass_type_names[]…

#algor #algorithm

21 viewsduangsuse ¯\_(ツ)_/¯ |学渣|母上千古, edited 09:26

duangsuse::Echo

如果有人买了（当然是不可能的，因为没有编译原理的 dalao 关注我？233333）《深入分析 GCC》这本书，会发现作者写了很多 AWK/sed/GNU bc/Bash 代码辅助分析（其实还用了 Graphviz）... 看到 188 面有一些代码可以生成这种树结构，抄下来看看： #c #linux #share #book #pl （我修改了一些标识符语义上的错误，格式化了代码，增强了代码语义的易读性） #include "gt-passes.h" char *pass_type_names[]…

想写个程序演示一下...

a: ds fds e
b: a
c: b a

这种嵌套链表...

a: ds fds e
b: $a
c: $b $a

语法严格一点的输入，至于那个特殊标记选什么都可以

a {
  b {
    c
  }
  d
}

这样的输入吧... 只是有点麻烦了就不容易实现接下来两个吧...

22 viewsduangsuse ¯\_(ツ)_/¯ |学渣|母上千古, 09:33

duangsuse::Echo

想写个程序演示一下... a: ds fds e b: a c: b a 这种嵌套链表... a: ds fds e b: $a c: $b $a 语法严格一点的输入，至于那个特殊标记选什么都可以 a { b { c } d } 这样的输入吧... 只是有点麻烦了就不容易实现接下来两个吧...

用 LinkedList 来说就是

rootNode
obj: a
next: node
ptr: b
next: node
ptr: c
next: NULL

... 这种抽象程度不够表述... 差了一个用来表示『自己』的指针

哦不.... 好像可以？ [a, b [] ]... 好吧这根本不是数组结构... 我抽象错了，不过这是就 tree （fork tree）的问题而言，对我这个问题它还是需要一个额外指针

[a, b [c], d]

self: a
next:
  self: b
  next:
    self: c
    next: null

... 这种数据结构看起来就像可以给列表命名的链表... 算了比较没用是我想多了... 来个正常链表

{
  a
  {
    b
    c
  }
  d
  {}
}

[a, [b, c], d, []]

21 viewsduangsuse ¯\_(ツ)_/¯ |学渣|母上千古, 09:50

duangsuse::Echo

#include <stdio.h>

int main(int argc, char *argv[]);

inline linked_list parse_input(FILE *fp);
inline void recur_dump_list(FILE *out, linked_list *list);

typedef struct node_st { 
  void *obj; node *next;
} node;

typedef struct linked_list_st {
  size_t len; node head; node tail;
} linked_list;

inline int llist_add(linked_list *list, void *obj);
inline void llist_remove(linked_list *list, int idx);
inline void llist_travse(linked_list *list, void (*)(void *));
inline void llist_deep_travse(linked_list *list, void (*)(void *));
inline int llist_find(linked_list *list, void *obj);
inline void *llist_shift(linked_list *list);
inline size_t llist_len(linked_list *list);

23 viewsduangsuse ¯\_(ツ)_/¯ |学渣|母上千古, edited 09:59

duangsuse::Echo

#include <stdio.h> int main(int argc, char *argv[]); inline linked_list parse_input(FILE *fp); inline void recur_dump_list(FILE *out, linked_list *list); typedef struct node_st { void *obj; node *next; } node; typedef struct linked_list_st { size_t…

#c #dev #emmm 🌝 不对啊，我怎么知道一个 void * 是不是 node ...

struct item_st {
  _Bool is_list;
  union {
    linked_list *ls;
    size_t ptr;
  };
}

21 viewsduangsuse ¯\_(ツ)_/¯ |学渣|母上千古, edited 10:07

duangsuse::Echo

所以最后又还是什么都没做啊.... 😶

21 viewsduangsuse ¯\_(ツ)_/¯ |学渣|母上千古, 10:08

duangsuse::Echo

如果有人买了（当然是不可能的，因为没有编译原理的 dalao 关注我？233333）《深入分析 GCC》这本书，会发现作者写了很多 AWK/sed/GNU bc/Bash 代码辅助分析（其实还用了 Graphviz）... 看到 188 面有一些代码可以生成这种树结构，抄下来看看： #c #linux #share #book #pl （我修改了一些标识符语义上的错误，格式化了代码，增强了代码语义的易读性） #include "gt-passes.h" char *pass_type_names[]…

哦，我明白了... 这是有三个子节点的树...

typedef struct lnode_st {
  void *self; lnode_st *sub; lnode_st *next;
} lnode;

这样我们就可以这样可视化此树了

nodea {
  a
  b
  c {
   d {
   }
  }
}

node b {

}

c
d
e

22 viewsduangsuse ¯\_(ツ)_/¯ |学渣|母上千古, 10:13

duangsuse::Echo

用 LinkedList 来说就是 rootNode obj: a next: node ptr: b next: node ptr: c next: NULL ... 这种抽象程度不够表述... 差了一个用来表示『自己』的指针哦不.... 好像可以？ [a, b [] ]... 好吧这根本不是数组结构... 我抽象错了，不过这是就 tree （fork tree）的问题而言，对我这个问题它还是需要一个额外指针 [a, b [c], d] self:…

结果就是我太蠢了... <del>蠢萌</del> 不是差了一个表述自己的，因为表述自己的已经有了，差的是表述子树的，有了这个才可以处理可能有 b, a {}, c 这种嵌套情况... ,a {},

>

根本不是数组结构

本来就不是啊... 是链表嘛... 幼儿园级别的入门数据结构算法白学了...

20 viewsduangsuse ¯\_(ツ)_/¯ |学渣|母上千古, edited 10:15

duangsuse::Echo

用 LinkedList 来说就是 rootNode obj: a next: node ptr: b next: node ptr: c next: NULL ... 这种抽象程度不够表述... 差了一个用来表示『自己』的指针哦不.... 好像可以？ [a, b [] ]... 好吧这根本不是数组结构... 我抽象错了，不过这是就 tree （fork tree）的问题而言，对我这个问题它还是需要一个额外指针 [a, b [c], d] self:…

另外 fork tree 本身就可能在节点上加子树... 所以再来一遍蠢<del>萌</del> duangsuse

20 viewsduangsuse ¯\_(ツ)_/¯ |学渣|母上千古, 10:16

duangsuse::Echo

duangsuse
  |
  |  bird
  |  |
  |  | flower
  |   - butterfly
  |
  | dog
  | dolphin
   - monkey

这个 bird 它不是子树是什么...所以再来一遍... 算了

19 viewsduangsuse ¯\_(ツ)_/¯ |学渣|母上千古, 10:19

duangsuse::Echo

This media is not supported in your browser

VIEW IN TELEGRAM

21 viewsduangsuse ¯\_(ツ)_/¯ |学渣|母上千古, 10:19

duangsuse::Echo

这样三个指针的话就可以了，即使下一项也是链表都可以

duangsuse
  |
  |  bird
  |  |
  |  | flower
  |   - butterfly
  |
  |  sealion
  |  |
  |  | tiger
  |   - smartisian
  |
  | dog
  | dolphin
   - monkey

可以被表述成这样

self: duangsuse\0
sub:
  self: bird\0
  sub:
    self: flower\0
    sub: NULL
    next:
      self: butterfly\0
      sub: NULL
      next: NULL
  next: NULL

... 太手写不友好算
先写结论：duangsuse 现在连递归都没学会
* 而且 C++ 也不是多会...

22 viewsduangsuse ¯\_(ツ)_/¯ |学渣|母上千古, 10:30

duangsuse::Echo

duangsuse {
  bird {
    flower,
    butterfly
  },
  sealion {
    tiger,
    smartisian
  },
  dog,
  dolphin
}

既得易见平凡<del>仿照文法显然，留作习题君思去，自己动手不难</del>

27 viewsduangsuse ¯\_(ツ)_/¯ |学渣|母上千古, 10:34

duangsuse::Echo

duangsuse { bird { flower, butterfly }, sealion { tiger, smartisian }, dog, dolphin } 既得易见平凡<del>仿照文法显然，留作习题君思去，自己动手不难</del>

最后我终于明白了... 因为智商比较低所以<del>因为智商比较低所以不会像大佬们一样开口直接上天所以才方便教你们实用知识啊</del> （迫真）

刚才写的全是错的，混淆了 sub 和 next （或者说是完全靠直觉...）现在不会了... :\

<del>到现在连递归都搞不懂的 duangsuse 是屑</del>

所谓易见就是以上文法。没有省略 , 和 {} 都写全了，换句话说就是

duangsuse {
  ...
}

self: duangsuse
sub: ...
next: NULL

bird {
  flower,
  butterfly
},
{},
dog,
dolphin

self: bird
sub:
  self: flower
  next:
    self: butterfly
next:
  next:
    self: dog
    next:
      self: dolphin

遵循 C 大法的指示，未显式初始化的都是

NULL

这种树就是有树结构的... 链表，允许给列表对象增加对接子树

data class LinkedList(Int size, ListItem head, ListItem tail)
data class ListItem(ListItem next)
data class ListObjectWithSublist(Object ptr, LinkedList sub): ListItem
data class ListObject(Object ptr): ListItem

（求别吐嘈 data class 语法错误没有填写至少一个字段