为一个不定长多维数字信号设计一个链表,并实现对其进行基本操作,包括初始化、求 数据元素个数操作、插入、删除、取数据元素、判非空 ,均值滤波、上采样和下采样

链表节点的结构体定义如下：

typedef struct node {
    int *data; // 数组指针
    int size; // 数组大小
    struct node *next; // 指向下一个节点的指针
} Node;

其中，`data`为数组指针，`size`为数组大小，`next`为指向下一个节点的指针。

链表的初始化函数如下：

Node *initList() {
    Node *head = (Node *)malloc(sizeof(Node)); // 创建头节点
    head->data = NULL;
    head->size = 0;
    head->next = NULL;
    return head;
}

链表的求数据元素个数操作函数如下：

int size(Node *head) {
    int cnt = 0;
    Node *p = head->next;
    while (p) {
        cnt += p->size;
        p = p->next;
    }
    return cnt;
}

链表的插入操作函数如下：

void insert(Node *head, int *data, int size, int pos) {
    Node *p = head;
    while (pos > 0 && p->next) {
        pos -= p->next->size;
        p = p->next;
    }
    if (pos < 0) { // 插入位置在当前节点之间
        pos += p->next->size;
        int *tmp = (int *)malloc(sizeof(int) * pos); // 将当前节点的后半段数据暂存
        memcpy(tmp, p->next->data + pos, sizeof(int) * (p->next->size - pos));
        p->next->size = pos; // 当前节点的后半段数据数量
        Node *newNode = (Node *)malloc(sizeof(Node)); // 创建新节点
        newNode->data = (int *)malloc(sizeof(int) * size);
        memcpy(newNode->data, data, sizeof(int) * size);
        newNode->size = size;
        newNode->next = p->next->next;
        p->next->next = newNode;
        p->next->size = pos; // 当前节点的前半段数据数量
        memcpy(p->next->data + pos, tmp, sizeof(int) * (p->next->size - pos));
        free(tmp);
    } else { // 插入位置在当前节点之后
        Node *newNode = (Node *)malloc(sizeof(Node)); // 创建新节点
        newNode->data = (int *)malloc(sizeof(int) * size);
        memcpy(newNode->data, data, sizeof(int) * size);
        newNode->size = size;
        newNode->next = p->next;
        p->next = newNode;
    }
}

链表的删除操作函数如下：

void delete(Node *head, int start, int end) {
    Node *p = head->next;
    int pos = 0; // 记录遍历到的位置
    while (p && pos + p->size <= start) { // 找到开始删除的位置
        pos += p->size;
        p = p->next;
    }
    while (p && pos < end) { // 逐个删除节点
        if (pos >= start && pos + p->size <= end) { // 删除整个节点
            Node *tmp = p->next;
            free(p->data); // 释放节点内存
            free(p);
            p = tmp;
        } else if (pos >= start) { // 删除部分数据
            int tmpSize = end - pos; // 待删除的数据数量
            int *tmp = (int *)malloc(sizeof(int) * (p->size - tmpSize)); // 暂存未删除的数据
            memcpy(tmp, p->data + tmpSize, sizeof(int) * (p->size - tmpSize));
            free(p->data); // 释放节点内存
            p->data = tmp;
            p->size -= tmpSize;
            pos += tmpSize;
            p = p->next;
        } else { // pos + p->size > end，删除部分数据
            int tmpSize = p->size - (end - pos); // 待删除的数据数量
            int *tmp = (int *)malloc(sizeof(int) * tmpSize); // 暂存未删除的数据
            memcpy(tmp, p->data, sizeof(int) * tmpSize);
            free(p->data); // 释放节点内存
            p->data = tmp;
            p->size = tmpSize;
            break;
        }
    }
}

链表的取数据元素操作函数如下：

int get(Node *head, int pos) {
    Node *p = head->next;
    while (p && pos >= p->size) {
        pos -= p->size;
        p = p->next;
    }
    if (p) {
        return p->data[pos];
    } else {
        return -1; // 数据越界
    }
}

链表的判非空操作函数如下：

bool isEmpty(Node *head) {
    return head->next == NULL;
}

链表的均值滤波操作函数如下：

void meanFilter(Node *head, int windowSize) {
    Node *p = head->next;
    while (p) {
        int *tmp = (int *)malloc(sizeof(int) * p->size); // 暂存滤波后的数据
        for (int i = 0; i < p->size; i++) {
            int sum = 0, cnt = 0;
            for (int j = i - windowSize / 2; j <= i + windowSize / 2; j++) {
                if (j >= 0 && j < p->size) {
                    sum += p->data[j];
                    cnt++;
                }
            }
            tmp[i] = sum / cnt; // 取平均值
        }
        free(p->data); // 释放节点内存
        p->data = tmp;
        p = p->next;
    }
}

链表的上采样操作函数如下：

void upsample(Node *head, int factor) {
    Node *p = head->next;
    while (p) {
        int *tmp = (int *)malloc(sizeof(int) * p->size * factor); // 暂存上采样后的数据
        for (int i = 0; i < p->size; i++) {
            for (int j = 0; j < factor; j++) {
                tmp[i * factor + j] = p->data[i];
            }
        }
        free(p->data); // 释放节点内存
        p->data = tmp;
        p->size *= factor;
        p = p->next;
    }
}

链表的下采样操作函数如下：

void downsample(Node *head, int factor) {
    Node *p = head->next;
    while (p) {
        int newSize = p->size / factor + (p->size % factor ? 1 : 0); // 下采样后的数据长度
        int *tmp = (int *)malloc(sizeof(int) * newSize); // 暂存下采样后的数据
        for (int i = 0; i < newSize; i++) {
            int sum = 0, cnt = 0;
            for (int j = i * factor; j < (i + 1) * factor && j < p->size; j++) {
                sum += p->data[j];
                cnt++;
            }
            tmp[i] = sum / cnt; // 取平均值
        }
        free(p->data); // 释放节点内存
        p->data = tmp;
        p->size = newSize;
        p = p->next;
    }
}