面试题：C语言一维数组下标引用的专家级挑战

数据结构选择：
- 由于数组数量不确定，可以使用动态数组结构，比如链表来存储这些数组的信息。在链表节点中，除了存储数组指针外，还可以存储数组的大小。例如：
```
typedef struct ArrayNode {
    int *array;
    int size;
    struct ArrayNode *next;
} ArrayNode;
```
映射关系的存储与计算方式：
- 映射关系可以通过函数指针数组来存储，每个函数指针对应一种映射关系计算逻辑。例如：
```
typedef int (*MappingFunc)(int, int);
MappingFunc mappingFuncs[3];
```
- 对于动态计算映射关系，每个映射函数 mappingFuncs[i] 接收两个参数，一个是当前数组的下标，另一个是当前数组的大小，返回对应的目标数组下标。例如，对于上述示例映射关系，可以这样定义映射函数：
```
int mapToArr2(int index, int arr1Size) {
    if (index < 0 || index >= arr1Size) {
        return -1; // 表示无效下标
    }
    return 2 * index;
}
int mapToArr3(int index, int arr1Size) {
    if (index < 0 || index >= arr1Size) {
        return -1;
    }
    return 3 * index;
}
```
- 在初始化时，将这些函数指针赋值到 mappingFuncs 数组中。
通过下标引用实现准确的元素访问和运算：
- 函数接收当前数组的下标、当前数组在链表中的位置（用于确定使用哪个映射函数）以及链表头指针。
- 在函数中，首先找到当前数组的信息（大小等），然后通过映射函数计算目标数组的下标，检查下标是否越界，最后获取目标数组元素并进行运算。

核心代码框架：

#include <stdio.h>
#include <stdlib.h>

typedef struct ArrayNode {
    int *array;
    int size;
    struct ArrayNode *next;
} ArrayNode;

typedef int (*MappingFunc)(int, int);

int mapToArr2(int index, int arr1Size) {
    if (index < 0 || index >= arr1Size) {
        return -1;
    }
    return 2 * index;
}

int mapToArr3(int index, int arr1Size) {
    if (index < 0 || index >= arr1Size) {
        return -1;
    }
    return 3 * index;
}

// 通用函数
int performOperation(int index, int currentArrayIndex, ArrayNode *head, MappingFunc *mappingFuncs) {
    ArrayNode *current = head;
    int i = 0;
    while (current && i < currentArrayIndex) {
        current = current->next;
        i++;
    }
    if (!current) {
        return -1; // 当前数组位置无效
    }
    int targetIndex = mappingFuncs[currentArrayIndex](index, current->size);
    if (targetIndex == -1) {
        return -1; // 无效下标
    }
    ArrayNode *targetArrayNode = head;
    // 找到目标数组节点
    while (targetArrayNode && targetIndex >= targetArrayNode->size) {
        targetArrayNode = targetArrayNode->next;
    }
    if (!targetArrayNode) {
        return -1; // 目标数组未找到或下标越界
    }
    int result = current->array[index] * targetArrayNode->array[targetIndex];
    return result;
}

int main() {
    int arr1[100];
    int arr2[200];
    int arr3[150];
    // 初始化数组...

    ArrayNode *head = (ArrayNode *)malloc(sizeof(ArrayNode));
    head->array = arr1;
    head->size = 100;
    head->next = (ArrayNode *)malloc(sizeof(ArrayNode));
    head->next->array = arr2;
    head->next->size = 200;
    head->next->next = (ArrayNode *)malloc(sizeof(ArrayNode));
    head->next->next->array = arr3;
    head->next->next->size = 150;
    head->next->next->next = NULL;

    MappingFunc mappingFuncs[3] = {NULL, mapToArr2, mapToArr3};

    int index = 10;
    int result = performOperation(index, 0, head, mappingFuncs);
    if (result != -1) {
        printf("Result: %d\n", result);
    } else {
        printf("Invalid operation\n");
    }

    // 释放链表内存...

    return 0;
}

星途面试题库

面试题：C语言一维数组下标引用的专家级挑战

知识考点

面试题答案