C 链表-插入

我试图在链表中插入一个文件的元素，我使用了两个函数，一个加载，另一个插入，显然，函数加载正在以正确的方式运行，但是函数插入正在启动实现，并且没有结束，测试我注意到她设法输入了文件的前3行，但是，由于代码很长，无法正确完成插入，因此，该部分存在问题：

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#define RECS_PATIO 2

struct Rec_Emp {
    char nome_rec[10];
    int uso_rec;
    int taxa_rec;
/*    struct Rec_Emp *prox; */
};

typedef struct Rec_Emp recuperadora;

struct Patio {
    char iden_patio;
    int capacidade;
    struct Patio *prox;
    struct Rec_Emp *lista[RECS_PATIO];
}; 

typedef struct Patio patio;

void insere_patio (patio *cabeca, patio *novo) {
    patio *p = cabeca; 

    while (p->prox != NULL)
        p = p->prox; 
    novo->prox = p->prox; 
    p->prox = novo;

}

void carrega_patio (patio *pa, patio p, recuperadora r1, recuperadora r2) {
    patio *pt = pa;
    FILE *f; 

    f = fopen ("portorec.txt", "rt");

    if (f == NULL) {
        printf ("Problema na abertura do arquivo");
        return;
    }

    while (!feof(f)) {
        fscanf (f, "%d %c %s %s %d %d %d %d", &p.capacidade, &p.iden_patio, r1.nome_rec, r2.nome_rec, &r1.uso_rec, &r2.uso_rec, &r1.taxa_rec, &r2.taxa_rec);

        p.lista[0] = &r1;
        p.lista[1] = &r2;
        insere_patio(pt, &p);   

    }
    fclose(f);
}

int main {

patio *PT;
    PT = malloc(sizeof(patio));
    PT->prox = NULL; 
    patio pat;
    recuperadora rec1, rec2;    
    carrega_patio(PT, pat, rec1, rec2);
}

---

在

main

中，您将

patio pat

声明为自动变量（在堆栈上分配）。默认情况下，自动变量不会初始化，因此您将得到堆栈上的任意随机垃圾作为

pat.prox

的值。我希望您的列表插入在内存中跟踪随机垃圾指针，查找

p->prox==NULL

此外，您没有在

carrega_patio

中动态分配内存。参数

patio p、Reciperadora r1、Reciperadora r2

都是结构，但这些结构将在每次循环中重复使用

想象一下，用一行数据填写一张纸质表格。然后从同一张纸质表格的顶部开始，用不同的数据行填写完全相同的表格。然后一次又一次

因为您没有单独分配内存，所以无法创建列表。您需要调用

malloc（）

或

calloc（）

为每个记录分配一张“新纸”

尝试以下方法（注意：未测试）： #包括 #包括

typedef const char * FILESPEC;

typedef struct rec_emp {
    #define RE_NOME_DIM 10

    int      re_taxa;
    int      re_uso;
    char     re_nome[RE_NOME_DIM];
} REC_EMP;

typedef struct patio {
    #define PA_LISTA_DIM 2

    struct patio *pa_prox;
    int     pa_capacidade;
    char    pa_iden;
    REC_EMP pa_lista[PA_LISTA_DIM];   /* NOTE: structs, NOT pointers */

    #define pare(pa,n) ((pa)->pa_lista[(n)])
} PATIO;

PATIO *
patio_novinho()
{
    PATIO * p = calloc(1, sizeof (PATIO));
    return p;
}

void
patio_insere(cabeca, novo)
    PATIO * cabeca;
    PATIO * novo;
{
    while (cabeca->pa_prox) {
        cabeca = cabeca->pa_prox;
    }
    novo->pa_prox = cabeca->pa_prox;
    cabeca->pa_prox = novo;
}

void
patio_carrega(cabeca, arquivo)
    PATIO * cabeca;
    FILESPEC arquivo;
{
    FILE *fp = fopen(arquivo, "rt");

    if (fp == NULL) {
        perror("patio_carrega: Problema na abertura do arquivo");
        exit(1);
    }

    while (!feof(fp) && !ferror(fp)) {

        PATIO * pa = patio_novinho();

        fscanf(fp, "%d %c %s %s %d %d %d %d",
            &pa->pa_capacidade,
            &pa->pa_iden,
            pare(pa,0).re_nome,
            pare(pa,1).re_nome,
            &(pare(pa,0).re_uso),
            &(pare(pa,1).re_uso),
            &(pare(pa,0).re_taxa),
            &(pare(pa,1).re_taxa)
        );

        patio_insere(cabeca, pa);

    }

    fclose(fp);
}

int
main()
{
    PATIO * cabeca = patio_novinho();
    patio_carrega(cabeca, "portorec.txt");

    /* more stuff here */
    exit(0);
}

---

插入时，通常需要将列表的地址作为参数传递，因为当为节点分配内存并将其指定为头（列表的地址）时，必须对实际指针本身而不是副本进行操作。这就是为什么insert至少必须检查两个条件的原因：（1）这是否是列表中的第一个节点；（2）如果不迭代到下一个要插入的空闲节点，我认为OP总是在列表的前面使用一个“虚拟”节点来解决这个问题。可以说，用堆换代码。是的，这就是为什么使用“一般”的原因，但是使用虚拟节点来屏蔽分配常常会遗漏一个重要的学习部分，这是完全理解操作列表中的第一个节点所必需的。这就是为什么我没有更多的评论就把它删除了。哇，老实说，我在c语言中还没有想到这样的解决方案。你用过的一些东西我甚至不知道有可能这么做，这个解决方案让我读了，对术语有了很好的理解。运行良好，插入和代码的其他部分现在正在运行，程序的条款是协调的。我欠你一品脱。谢谢

typedef const char * FILESPEC;

typedef struct rec_emp {
    #define RE_NOME_DIM 10

    int      re_taxa;
    int      re_uso;
    char     re_nome[RE_NOME_DIM];
} REC_EMP;

typedef struct patio {
    #define PA_LISTA_DIM 2

    struct patio *pa_prox;
    int     pa_capacidade;
    char    pa_iden;
    REC_EMP pa_lista[PA_LISTA_DIM];   /* NOTE: structs, NOT pointers */

    #define pare(pa,n) ((pa)->pa_lista[(n)])
} PATIO;

PATIO *
patio_novinho()
{
    PATIO * p = calloc(1, sizeof (PATIO));
    return p;
}

void
patio_insere(cabeca, novo)
    PATIO * cabeca;
    PATIO * novo;
{
    while (cabeca->pa_prox) {
        cabeca = cabeca->pa_prox;
    }
    novo->pa_prox = cabeca->pa_prox;
    cabeca->pa_prox = novo;
}

void
patio_carrega(cabeca, arquivo)
    PATIO * cabeca;
    FILESPEC arquivo;
{
    FILE *fp = fopen(arquivo, "rt");

    if (fp == NULL) {
        perror("patio_carrega: Problema na abertura do arquivo");
        exit(1);
    }

    while (!feof(fp) && !ferror(fp)) {

        PATIO * pa = patio_novinho();

        fscanf(fp, "%d %c %s %s %d %d %d %d",
            &pa->pa_capacidade,
            &pa->pa_iden,
            pare(pa,0).re_nome,
            pare(pa,1).re_nome,
            &(pare(pa,0).re_uso),
            &(pare(pa,1).re_uso),
            &(pare(pa,0).re_taxa),
            &(pare(pa,1).re_taxa)
        );

        patio_insere(cabeca, pa);

    }

    fclose(fp);
}

int
main()
{
    PATIO * cabeca = patio_novinho();
    patio_carrega(cabeca, "portorec.txt");

    /* more stuff here */
    exit(0);
}