标签: data-structures

假设您有一个非常简单的数据结构:

(personId, name)

...并且您希望将其中的一些存储在javascript变量中.在我看来,你有三个选择:

// a single object
var people = {
    1 : 'Joe',
    3 : 'Sam',
    8 : 'Eve'
};

// or, an array of objects
var people = [
    { id: 1, name: 'Joe'},
    { id: 3, name: 'Sam'},
    { id: 8, name: 'Eve'}
];

// or, a combination of the two
var people = {
    1 : { id: 1, name: 'Joe'},
    3 : { id: 3, name: 'Sam'},
    8 : { id: 8, name: 'Eve'} …

有人可以解释一下这两种数据结构之间的主要区别是什么吗？我一直试图在网上找到一个突出差异/相似之处的来源,但我没有找到任何太丰富的信息.在哪种情况下,一个人比另一个人更受欢迎？什么实际情况使一个"更好"使用比另一个？

我想在YAML中合并数组,并通过ruby加载它们 -

some_stuff: &some_stuff
 - a
 - b
 - c

combined_stuff:
  <<: *some_stuff
  - d
  - e
  - f

我想将组合数组作为 [a,b,c,d,e,f]

我收到错误:在解析块映射时没有找到预期的键

如何在YAML中合并数组？

从byte []数组填充C#结构的最佳方法是什么,其中数据来自C/C++结构？C结构看起来像这样(我的C很生锈):

typedef OldStuff {
    CHAR Name[8];
    UInt32 User;
    CHAR Location[8];
    UInt32 TimeStamp;
    UInt32 Sequence;
    CHAR Tracking[16];
    CHAR Filler[12];
}

并填写这样的东西:

[StructLayout(LayoutKind.Explicit, Size = 56, Pack = 1)]
public struct NewStuff
{
    [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 8)]
    [FieldOffset(0)]
    public string Name;

    [MarshalAs(UnmanagedType.U4)]
    [FieldOffset(8)]
    public uint User;

    [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 8)]
    [FieldOffset(12)]
    public string Location;

    [MarshalAs(UnmanagedType.U4)]
    [FieldOffset(20)]
    public uint TimeStamp;

    [MarshalAs(UnmanagedType.U4)]
    [FieldOffset(24)]
    public uint Sequence;

    [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 16)]
    [FieldOffset(28)]
    public string Tracking;
}

什么是复制OldStuff到的最佳方式NewStuff,如果OldStuff作为byte []数组传递？ …

我刚刚在Java 6 API上看到了这个数据结构,我很好奇它何时会成为一个有用的资源.我正在攻读scjp考试,虽然我已经看过提到它的模拟考试题目,但我并没有在Kathy Sierra的书中看到它.

Java是否具有C++的模拟struct:

struct Member {
  string FirstName; 
  string LastName;  
  int BirthYear; 
};

我需要使用自己的数据类型.

从最近的SO问题(参见在python中创建一个由列表索引的字典)我意识到我可能对python中可散列和不可变对象的含义有一个错误的概念.

• 在实践中,什么是可以平均的？
• hashable和immutable之间的关系是什么？
• 是否有可变对象是可清洗的或不可变的对象？

给定n个对象的数组,假设它是一个字符串数组,它具有以下值:

foo[0] = "a";
foo[1] = "cc";
foo[2] = "a";
foo[3] = "dd";

如何删除/删除数组中等于"a"的所有字符串/对象？

我正在优化一些主要瓶颈正在运行的代码并访问一个非常大的类似结构的对象列表.目前我正在使用namedtuples,以提高可读性.但是使用'timeit'的一些快速基准测试表明,在性能是一个因素的情况下,这确实是错误的方法:

用a,b,c命名的元组:

>>> timeit("z = a.c", "from __main__ import a")
0.38655471766332994

使用__slots__a,b,c的类:

>>> timeit("z = b.c", "from __main__ import b")
0.14527461047146062

带键a,b,c的字典:

>>> timeit("z = c['c']", "from __main__ import c")
0.11588272541098377

具有三个值的元组,使用常量键:

>>> timeit("z = d[2]", "from __main__ import d")
0.11106188992948773

使用常量键列出三个值:

>>> timeit("z = e[2]", "from __main__ import e")
0.086038238242508669

具有三个值的元组,使用本地密钥:

>>> timeit("z = d[key]", "from __main__ import d, key")
0.11187358437882722

使用本地密钥列出三个值:

>>> timeit("z = e[key]", "from __main__ import e, key")
0.088604143037173344

首先,这些小timeit测试是否会使它们无效？我跑了几次,以确保没有任何随机系统事件抛出它们,结果几乎相同.

看起来字典在性能和可读性之间提供了最佳平衡,而类别排在第二位.这是不幸的,因为为了我的目的,我还需要对象是序列式的; 因此我选择了namedtuple. …

Fibonacci数字已经成为计算机科学学生递归的一个流行的介绍,并且有一个强烈的论据,即它们在自然界中存在.出于这些原因,我们很多人都熟悉它们.

它们也存在于其他地方的计算机科学中; 在基于序列的令人惊讶的有效数据结构和算法中.

我想到了两个主要的例子:

• 斐波那契堆比二项式堆具有更好的摊销运行时间.
• Fibonacci搜索在有序数组上与二进制搜索共享O(log N)运行时间.

这些数字是否有某些特殊属性可以使它们优于其他数字序列？这是空间质量吗？他们还有哪些其他可能的应用程序？

这对我来说似乎很奇怪,因为在其他递归问题中有许多自然数字序列,但我从未见过加泰罗尼亚语堆.