(中科探海笔试题)

题目：

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

思路：

用四个子函数实现四个功能:创建，插入，获取数组容量，获取数据个数

首先，先构造一个结构体：

#include<stdio.h>
#include<stdlib.h>
typedef struct node
{
    float *data;     //数据
    int neicun;      //数据容量
    int size;        //个数
} node_t, *node_p;

创建函数：

node_p chuangjian(int neicun)
{
    node_p p = (node_p)malloc(sizeof(node_t));
    if (p == NULL)
    {
        perror("err");
        return NULL;
    }
    p->data = (float *)malloc(sizeof(float) * neicun);
    if (p->data == NULL)
    {
        perror("err");
        return NULL;
    }
    p->size = 0;
    p->neicun = neicun;
    return p;
}

 获取容量大小，个数：

int getneicun(node_p p)
{
    return p->neicun;
}
int getsize(node_p p)
{
    return p->size;
}

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

node_p add(node_p pA, node_p pB)
{
    int size = getsize(pA) < getsize(pB) ? getsize(pA) : getsize(pB);
    int neicunC = getneicun(pA) > getneicun(pB) ? getneicun(pA) : getneicun(pB);
    node_p result = chuangjian(neicunC);
    for (int i = 0; i < size; i++)
    {
        charu(result, pA->data[i] + pB->data[i]);
    }
    return result;
}

总代码： 

#include<stdio.h>
#include<stdlib.h>
typedef struct node
{
    float *data;
    int neicun;
    int size;
} node_t, *node_p;

node_p chuangjian(int neicun)
{
    node_p p = (node_p)malloc(sizeof(node_t));
    if (p == NULL)
    {
        perror("err");
        return NULL;
    }
    p->data = (float *)malloc(sizeof(float) * neicun);
    if (p->data == NULL)
    {
        perror("err");
        return NULL;
    }
    p->size = 0;
    p->neicun = neicun;
    return p;
}
void charu(node_p p, float data)
{
    if (p->size < p->neicun)
    {
        p->data[p->size] = data;
        p->size++;
    }
    else
    {
        printf("数组已满，无法放入数据");
    }
}
int getneicun(node_p p)
{
    return p->neicun;
}
int getsize(node_p p)
{
    return p->size;
}
void shifang(node_p p)
{
    free(p->data);
    free(p);
}

node_p add(node_p pA, node_p pB)
{
    int size = getsize(pA) < getsize(pB) ? getsize(pA) : getsize(pB);
    int neicunC = getneicun(pA) > getneicun(pB) ? getneicun(pA) : getneicun(pB);
    node_p result = chuangjian(neicunC);
    for (int i = 0; i < size; i++)
    {
        charu(result, pA->data[i] + pB->data[i]);
    }
    return result;
}

int main(int argc, char const *argv[])
{
    int neicun = 10;
    node_p p = chuangjian(neicun);
    for (int i = 0; i < 5; i++)
    {
        charu(p, i);
    }
    printf("数组容量:%d\n", getneicun(p));
    printf("数组内数据个数：%d\n", getsize(p));
    shifang(p);

    int neicunA = 20;
    node_p pA = chuangjian(neicunA);
    for (int i= 0; i < 10; i++)
    {
        charu(pA, i);
    }
    int neicunB = 30;
    node_p pB = chuangjian(neicunB);
    for (int i = 0; i < 6; i++)
    {
        charu(pB, i);
    }
    node_p pC = add(pA, pB);
    printf("均含数据部分相加为：");
    for (int i = 0; i < getsize(pC); i++)
    {
        printf("%.1f  ", pC->data[i]);
    }
    printf("\n");
    shifang(pA);
    shifang(pB);

    node_p pd=paixu(pC);

    return 0;
}