Question

使用python语法，我们有深度列表，如

示例1 - list = [1, [2, 3], 4]

示例2 - list = [[1, [1, 1]], 1, [1, 1]]

其中每个子集必须在运行时属于类list或int。

使用C语言，维护此类数据所需的数据模型是什么？

注意：根据示例

，尺寸不固定

Answer 1

使用元素结构的前向声明。

// declare existence of a structure type to be used for array elements.
struct some_type_S;

// The list type is a count and pointer to an array of `struct some_type_S`
// Alternative: use a variable length array for `element`
typedef struct list_S {
  size_t num_elements;
  struct some_type_S *element;
  // Alternative: use C99 and a variable length array for `element`
  // struct some_type_S element[];
} list_T;

// Now define `struct some_type_S` as
// a flag (is_int) and a union of an `int` and a pointer to a list
typedef struct some_type_S {
  _Bool is_int;
  union {
    int i;
    list_T *list;
  } u;
} some_type_T;

快乐的C编码。

Answer 2

您想要的数据结构似乎是树形。每个叶子是一个int，或者是一个可变大小的列表。我所知道的目前没有这个实现，所以你必须实现自己的树结构。您可以使用动态数组（如

）实现此目的

struct Tree{
    struct Tree* list;
    //if leafOrBranch is true, consider this a branch and branchsize is the size of list, if it is false, consider this a leaf and branchsize is the content
    int branchSize;
    bool leafOrBranch;
}

这有一个缺点，即在增加其大小时需要重新分配列表中的内存，因此可以使用链接列表或二进制树或其他东西来实现加速。

Answer 3

要在C中拥有这样的结构，你需要做很多工作（或链接其他人的代码）。而且SO不是代码编写服务。但是，我会告诉你如何做到这一点：

C不支持开箱即用的动态长度数组（列表）。（所谓的可变长度数组对你的情况没有帮助。）但是你会在网上找到它的实现。（通常列表是固定大小缓冲区的链接列表。）
C既不支持动态输入也不支持通用输入。要编写通用代码，因为数组实现必须具有，通常数组不存储有效负载本身，而是指向它的指针。指针可以键入void*，基本上意味着“指向某事物的指针”。因此，您可以存储指向整数或其他列表的指针。
或者。您希望在同一列表中并排存储整数和整数列表。这对C. Esp来说是不寻常的。 C程序没有关于其对象的元信息。无法询问void *，它指向的是什么类型。因此，您需要一个存储的结构，无论是包含数字还是列表，然后是存储数字的组件（如果是列表则不使用）和指向列表的指针（如果是数字则不使用）。（您可以使用铸件或联合来优化这一点，但这是第一种方法。）

所以，将所有事情放在一起：

您需要管理列表的代码。你会在网上找到它。

您可以定义自己的结构，其中包含指向另一个列表的数字或指针以及它存储的数据类型。

每个清单的分配必须由您自己完成。

还有很长的路要走。我们很快就会看到你有额外的Q. ; - ）

Answer 4

或者，如果您更喜欢链接结构：

import sys
import matplotlib
def fourier(time,array):

    fft = np.fft.fft(array*np.hanning(len(array)))

    Npts = len(array)
    spacing_array = time[::-1][:-1][::-1] - time[:-1]

    if np.mean(spacing_array) - spacing_array[0] > 1.e-16:
            print "time axis not equally separated. cannot compute fft"
            sys.exit()
    spacing = spacing_array[0]

    freq = np.fft.fftfreq(Npts, spacing)

    return freq,fft

if __name__ == "__main__":
    import numpy as np
    import matplotlib.pyplot as plt

    # generate a sample signal
    sample_rate = 100.0
    nsamples = int(2.e3)
    t = np.arange(nsamples) / sample_rate
    x = np.cos(2*np.pi*0.5*t) + 0.2*np.sin(2*np.pi*2.5*t+0.1) + \
            0.2*np.sin(2*np.pi*15.3*t) + 0.1*np.sin(2*np.pi*16.7*t + 0.1) + \
                0.1*np.sin(2*np.pi*23.45*t+.8)
    y = np.cos(7*np.pi*1.1*t) + 3*np.sin(0.2*np.pi*2.8*t+1) + \
            0.2*np.sin(8*np.pi*2.7*t) + 1*np.sin(2*np.pi*t + 2.1) + \
                0.1*np.sin(0.2*np.pi*0.45*t+1.4)
    z = x*np.exp(y*1j)

    z_freq,z_fft = fourier(t,z)

    plt.clf()
    plt.figure(figsize=(8,12))

    plt.subplot(4,1,1) # original signal
    plt.plot(t,np.absolute(z))

    plt.subplot(4,1,2) # fourier transform
    plt.semilogy(sorted(z_freq),[b for (a,b) in sorted(zip(z_freq,np.absolute(z_fft)/nsamples))])

    # filtering
    plt.subplot(4,1,3)
    idx = np.where(np.abs(z_freq)>2.0)
    z_fft[idx]=0
    z_filter = np.fft.ifft(z_fft)
    plt.plot(t,np.real(z_filter))

    z_freq,z_fft = fourier(t,z_filter)
    plt.subplot(4,1,4)
    plt.semilogy(sorted(z_freq),[b for (a,b) in sorted(zip(z_freq,np.absolute(z_fft)/nsamples))])
    plt.show()

了解这是如何代表＆＃34; deep＆＃34;列表，读取此维基百科条目list。

现在我们可以创建示例列表：

// A cell is a basic variant type whose value can be either
//  * An integer, or
//  * A pair of cells
struct cell_t;
struct pair_t;

// Enum of cell type, currently INT or PAIR
typedef enum { INT, PAIR } cell_type;

// Definition of type cell and pair, which are pointers to the respective structs
typedef struct cell_t* cell;
typedef struct pair_t* pair;

// Definition of pair_t: two pointers to cell (first and second)
// For a list structure, the type of second should always be PAIR.
struct pair_t {
    cell first;
    cell second;
};

// Definition of cell_t: type + union value
struct cell_t {
    cell_type type;
    union {
        int  i;
        pair p;
    } value;
};

// Constructors
//////////////////////////////////////////////////////////////////////////////////
// Returns an integer cell
cell Int(int i);
// Returns a pair cell
cell Pair(cell a, cell b);
// Returns a empty pair, type: PAIR, value.p==NULL
cell Nil();

这些数据需要什么样的数据模型？

4 个答案: