中科探海笔试题（数据结构顺序栈+文件IO全面考察）

[1]思考一种数据结构与方法，可以创建一个单精度浮点型数组，数组能够存储N个单精度浮点型数据（即容量），写一个结构体与对应的函数，完成创建数组、放入数据、获取数组容量、获取数组内浮点数据个数四个函数，随后调用对应函数放入M（M<N）个单精度浮点数据（即1....M）。

#include <stdio.h>  
#include <stdlib.h>  
  
// 问题1：创建单精度浮点型数组  
typedef struct 
{  
    float* data;  
    int capacity;  
    int count;  
} FloatArray;  

//创建数组
FloatArray* createFloatArray(int capacity) 
{  
    FloatArray* array = (FloatArray*)malloc(sizeof(FloatArray));  
    array->data = (float*)malloc(capacity * sizeof(float));  
    array->capacity = capacity;  
    array->count = 0;  
    return array;  
}  

//销毁
void destroyFloatArray(FloatArray* array) 
{  
    free(array->data);  
    free(array);  
}  

//插入数据
void insertData(FloatArray* array, float data) 
{  
    if (array->count < array->capacity) 
    {  
        array->data[array->count++] = data;  
    }  
} 

//获取数组容量
int getCapacity(FloatArray* array) 
{  
    return array->capacity;  
}  

//获取数组内浮点数据个数
int getCount(FloatArray* array) 
{  
    return array->count;  
}  

[2]编写一个函数，利用[1]中的数据结构与函数创建两个数组a，b，容量为NA与NB，其中（NA ≠ NB)，分别放入MA和MB个不同的浮点数据，其中（MA<NA 且MB< NB)，随后将其均含数据的部分相加，将结果写入数组c中并返回。

// 问题2：创建两个数组并将数据相加  
FloatArray* addArrays(FloatArray* arrayA, int MA, FloatArray* arrayB, int MB) 
{  
    int capacity = getCapacity(arrayA) < getCapacity(arrayB) ? getCapacity(arrayA) : getCapacity(arrayB);  
    FloatArray* result = createFloatArray(capacity);  
    for (int i = 0; i < capacity ; i++) 
    {  
        insertData(result, arrayA->data[i] + arrayB->data[i]);  
    }  
    destroyFloatArray(arrayA);  
    destroyFloatArray(arrayB);  
    return result;  
}  

[3]编写一个函数，对问题[2]中的数组进行降序排序，并将结构放入数组d中并返回。

// 问题3：对数组进行降序排序  
void sortDescending(FloatArray* array) 
{  
    int count = getCount(array);  
    for (int i = 0; i < count - 1; i++) 
    {  
        for (int j = 0; j < count - i - 1; j++) 
        {  
            if (array->data[j] < array->data[j + 1]) 
            {  
                float temp = array->data[j];  
                array->data[j] = array->data[j + 1];  
                array->data[j + 1] = temp;  
            }  
        }  
    }  
}  

[4]编写一个函数，将问题[3]的结果，序列化为自定义的格式写入一个二进制文件中。要求自定义一种二进制格式，注意考虑数组的容量与数据的数量如何存储。

// 问题4：序列化数组数据为二进制文件  
void serialize(FloatArray* array, const char* filename) 
{  
    FILE* file = fopen(filename, "wb");  
    if (file == NULL) 
    {  
        printf("Failed to open file\n");  
        return;  
    }  
    int count = getCount(array);  
    fwrite(&count, sizeof(int), 1, file); // 写入数据个数  
    fwrite(&array->data[0], sizeof(float), count, file); // 写入数据内容  
    fclose(file);  
}  

[5]编写一个函数，将问题[4]生成的文件数据读出来，并反序列化为[1]中的数据结构。

// 问题5：反序列化二进制文件为数组数据  
FloatArray* deserialize(const char* filename) 
{  
    FILE* file = fopen(filename, "rb");  
    if (file == NULL) 
    {  
        printf("Failed to open file\n");  
        return NULL;  
    }  
    int count;  
    fread(&count, sizeof(int), 1, file); // 读取数据个数  
    FloatArray* array = createFloatArray(count); // 创建对应容量的数组  
    fread(&array->data[0], sizeof(float), count, file); // 读取数据内容  
    fclose(file);  
    return array;  
}