标签: recursive-datastructures

我有一个非托管结构，我想将其编组到 c 锐利，它看起来基本上是这样的：

struct MyStruct{  
    /* ... some stuff ... */
    int numChilds;  
    MyStruct *childs;
}

我相信我必须编写一个自定义编组器，但我不确定如何继续。

我需要找到两个维基百科页面之间的最短距离("跳")

我有一个方法来提取页面上的所有内部wiki链接

我知道起始目的地和结束目的地,但我对如何从数据中提取跳数一无所知

到目前为止,我一直在使用链接提取方法填充字典,其中键是页面上的链接,值是从中删除的页面.

如果有人有任何想法,一个良好的数据结构将保持信息,然后如何看待它我会非常感激

是否可以使用C++ 11 使用构造函数initializer_list组装递归定义的类Foo,如下所示constexpr:

template <size_t N>
struct Foo {
  constexpr Foo(int x, Foo<N-1> f) : x(x), xs(xs) {}
  int x;
  Foo<N-1> xs;
};

template <> struct Foo<0> {};

我可以初始化一个Foo<3>使用:

int main(int argc, char *argv[])
{
  Foo<3> a = Foo<3>(1,Foo<2>(2,Foo<1>(3,Foo<0>())));
  return 0;
}

最好使用Foo <3> a = {1,2,3}.如果有一个constexpr tail功能,initializer_list我认为它应该工作.

我试图从一系列代表深度的字符串中提取:

'foo/bar/x'
'foo/bar/baz/x'
'foo/bar/baz/x'
'foo/bar/lol/x'

x我不关心的数字在哪里.我已经完成了分裂/和循环,在PHP中,我会做一些事情,比如检查我在循环中的位置(使用for (i=0; etc)),然后使用它来确定我构建输出数组的深度,如:

output['foo']['bar'] = 1
output['foo']['bar']['baz'] = 2
output['foo']['bar']['lol'] = 1

问题是"深度"是动态的,可能只是3/4深(我可以通过对价值的大量检查i和单独处理它来解释)或者说10或更深,在这种情况下某种类型的递归函数可能是最好的.

我遇到了一个问题,即将字符串作为数组索引我需要使用字典,但是你必须在字典中指定类型,这意味着你需要知道高级的深度(如果我是的话,请纠正我)在实例化字典对象时.

我猜一个攻击可能就像调用一个递归函数,每次调用它来传递i指示深度,然后函数调用自己i每次递减,直到它从该输入字符串构建树的一部分,但它是什么存储我在C#中使用的结构,我不确定.

最终输出将是一个CSV,我可以打开它作为电子表格,如下所示:

Foo        0
|__Bar     1
   |__Baz  2
   |__Lol  1

也许对于溶液中的一种方向是使用纯C#阵列和简单地存储的标题(例如foo)在那里,保持了阵列indicies,这可能是最好的做法反正的信息.谢谢.

我试图围绕着如何获得无限列表来解决这个问题...这是我的路障:

您有一个类型列表A,并A实现Ord类型类.您可以像这样描述一系列有序元素(例如,intergers):

[1..6]

这相当于......

Cons 1 (Cons 2 (Cons 3 (Cons 4 (Cons 5 (Cons 6 (Empty))))))

haskell如何知道如何构建无限列表？haskell能够创建支持的任何数据类型的无限列表Ord吗？

我已经开始使用数据类型,但我对以下内容感到困惑:

data Natural = Zero | Succ Natural

add :: Natural -> Natural -> Natural

add m Zero = m

add m (Succ n) = Succ (add m n)

这是如何加入工作的.我理解这Natural 3是代表的,Succ(Succ(Succ 0)))虽然这对我来说仍然不是100%明确的,即价值本身或者是什么减少.我想逐步了解添加.

PS:这是摘自Richard Bird的"功能编程简介"一书.

我有以下 JSON。

[{
    "ID": "Root_1",
    "Name": "Root_1",                   
    "ParentID": "",
    "Sequent": 1
},
{
    "ID": "Root_2",
    "Name": "Root_2",                   
    "ParentID": "",
    "Sequent": 2
},              
{
    "ID": "Root_1_Sub_1_Child_1",
    "Name": "Root_1_Sub_1_Child_1",                 
    "ParentID": "Root_1_Sub_1",
    "Sequent": 1
},
{
    "ID": "Root_1_Sub_1_Child_2",
    "Name": "Root_1_Sub_1_Child_2",                 
    "ParentID": "Root_1_Sub_1",
    "Sequent": 2
},
{
    "ID": "Root_1_Sub_1",
    "Name": "Root_1_Sub_1",                 
    "ParentID": "Root_1",
    "Sequent": 1
}]

我想将我的 JSON 更改为如下。

[{
    "ID": "Root_1",
    "Name": "Root_1",
    "ParentID": "",
    "Sequent": 1,
    "Sub": [{
        "ID": "Root_1_Sub_1",
        "Name": "Root_1_Sub_1",
        "ParentID": "Root_1",
        "Sequent": 1,
        "Sub": [{
            "ID": "Root_1_Sub_1_Child_1",
            "Name": "Root_1_Sub_1_Child_1", …

我有一个以以下格式输出数据的端点：

const result = [
  {id: 4, parentId: null, name: 'Fruits & Veggies'},
  {id: 12, parentId: 133, name: 'Sanguinello'},
  {id: 3, parentId: 4, name: 'Fruits'},
  {id: 67, parentId: 98, name: 'Sesame'},
  {id: 23, parentId: 3, name: 'Orange'},
  {id: 7, parentId: null, name: 'Grains'},
  {id: 134, parentId: 7, name: 'Flour'},
  {id: 3512, parentId: 23, name: 'Navel Orange'},
  {id: 98, parentId: null, name: 'Seeds'},
  {id: 4122, parentId: 58, name: 'Lamb'},
  {id: 133, parentId: 23, name: 'Blood Orange'},
];

我需要创建一个递归函数来获取一个潜在的无限嵌套对象，该对象的格式如下：

const infiniteTreeOutput = …

我可以在 C 中以自己的结构（递归结构）创建一个结构的实例（尽管现在我当然会这样做，因为这有点奇怪和棘手）？

喜欢：

int main(void)
{
    struct type
    {
         char name[20];
         char address[35];

         struct type;
    };

    return 0;
}

当然，编译器给了我警告：

warning: declaration does not declare anything  

但是他/它让它通过并给了我一个可执行程序。

因为我想用 C++ 编译器编译相同的程序，他/它抛出了一个错误：

 error: ‘main()::type::type’ has the same name as the class in which it is declared

所以问题是针对 C，而不是针对 C++。

• 我可以这样做，而不会对我的程序造成任何更深层次的问题吗？
• 我可能会使用这种技术进入未定义或未指定的行为吗？
• 是否有任何理由不这样做（编译/性能问题）？

提前致谢。

二叉树遍历如前序遍历、中序遍历、后序遍历、层序遍历是很多IT公司经常面试的。

记得前序遍历和中序遍历的迭代实现让我很困惑。

以下是leetcode上的问题。

https://leetcode.com/problems/binary-tree-inorder-traversal/

https://leetcode.com/problems/binary-tree-preorder-traversal/