Как заполнить связанный список элементами, которые у меня уже есть?

Question

Я пытаюсь создать связанный список с имеющимися у меня элементами, но для этого мне нужно 24 узла, и я не хочу, чтобы получилось так:

head->next->next->next->next->next->next->next->id = 1;

Как я могу предотвратить это?

Я пытался создать что-то подобное, но все узлы (очевидно) указывают на одни и те же данные.

void init_board(block **head)
{
    block temp;

    temp.id=0;
    temp.name="Start";
    temp.price=0;
    temp.rent=0;
    temp.next = NULL;

    *head = &temp;
    (*head)->next = NULL;
    (*head)->next = (block*) malloc(sizeof(block*));
    temp = head->next;

    temp.id=1;
    temp.name="End";
    temp.price=16000;
    temp.rent=800;
    temp.next = NULL;
}

Answer 1

struct link 
{
  int data;
  int dataOne;
  // data n....
   struct link* link;
};
// HeadNode
struct link* pHeadLink = NULL;
//add the link and return the current.
struct link* appendLink()
{
   if(pHeadLink == NULL)
   {
     pHeadLink = (struct link*) malloc(sizeof(struct link));
     pHeadLink->link = NULL;
     return pHeadLink;
  }
  struct link *pTempLink = pHeadLink;
  while(pTempLink->link != NULL)
  {
     pTempLink = pTempLink->link;
  }
  pTempLink->link = (struct link*) malloc(sizeof(struct link));
  pTempLink->link->link = NULL;
  return pTempLink;
}
// calling function:
int fun()
{

 loop() // loop for 24 times. 
{ 
  struct link* pFillDataLink = appendLink();
   // here you can fill rest the items like below.
   pFillDataLink->data = 34;
   pFillDataLink->dataOne = 334; 
   // etc.... 
}
}

Answer 2

Я пытаюсь создать связанный список с имеющимися у меня элементами, но для этого мне нужно 24 узла, и я не хочу, чтобы получилось так:

head-> next->следующая-> следующая-> следующая-> следующая-> следующая-> следующая-> id = 1;Как я могу предотвратить это?

обновление head (не только *head)

 block temp;
 ...
 temp = head->next;

вы не можете этого сделать,потому что temp это s struct , но next указатель

Я пытался создать что-то подобное, но все узлы (очевидно) указываютте же данные.

вам нужно выделить новую ячейку для всех новых элементов, в том числе для первого, который вы в данный момент положили в стек ( никогда возвращает адрес чего-то, сохраненного встек)

( head) -> следующий = (блок ) malloc (sizeof (блок *));

это не то, чтовы хотите, вам нужно выделить блок , а не блок *

Пример инициализации с двумя ячейками:

void init_board(block **plast)
{
  *plast = malloc(sizeof(block));
  (*plast)->id=0;
  (*plast)->name="Start";
  (*plast)->price=0;
  (*plast)->rent=0;
  (*plast)->next = malloc(sizeof(block));
  plast = &(*plast)->next;
  (*plast)->id=1;
  (*plast)->name="End";
  (*plast)->price=16000;
  (*plast)->rent=800;
  (*plast)->next = NULL;
}

int main()
{
   block * l;

   init_board(&l);
}

---

Конечно, если у вас есть 20 блоков для инициализации для расширения, каждый случай нецелесообразен, это могут быть значения из файла или массива, подобного этому:

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

typedef struct block {
  int id;
  const char * name;
  int price;
  int rent;
  struct block * next;
} block;

const block Boards[] = {
  { 0, "Start", 0, 0, NULL },
  { 2, "Intermediate", 123, 456, NULL },
  { 1, "End", 16000, 800, NULL }
};

void init_board(block **plast)
{
  for (const block * b = Boards; b != Boards + sizeof(Boards)/sizeof(Boards[0]); ++b) {
    *plast = malloc(sizeof(block));

    (*plast)->id = b->id;
    (*plast)->name = b->name;
    (*plast)->price = b->price;
    (*plast)->rent = b->rent;
    (*plast)->next = NULL;
    plast = &(*plast)->next;
  }
}

int main()
{
  block * blocks;

  init_board(&blocks);

  /* debug */
  for (block * b = blocks; b != NULL; b = b->next)
    printf("%d %s %d %d\n", b->id, b->name, b->price, b->rent);

  /* free resources */
  while (blocks != NULL) {
    block * b = blocks;

    blocks = blocks->next;
    free(b);
  }

  return 0;
}

Компиляция и выполнение:

pi@raspberrypi:/tmp $ gcc -pedantic -Wextra -Wall l.c
pi@raspberrypi:/tmp $ ./a.out
0 Start 0 0
2 Intermediate 123 456
1 End 16000 800

Исполнение под valgrind :

pi@raspberrypi:/tmp $ valgrind ./a.out
==6819== Memcheck, a memory error detector
==6819== Copyright (C) 2002-2017, and GNU GPL'd, by Julian Seward et al.
==6819== Using Valgrind-3.13.0 and LibVEX; rerun with -h for copyright info
==6819== Command: ./a.out
==6819== 
0 Start 0 0
2 Intermediate 123 456
1 End 16000 800
==6819== 
==6819== HEAP SUMMARY:
==6819==     in use at exit: 0 bytes in 0 blocks
==6819==   total heap usage: 4 allocs, 4 frees, 1,084 bytes allocated
==6819== 
==6819== All heap blocks were freed -- no leaks are possible
==6819== 
==6819== For counts of detected and suppressed errors, rerun with: -v
==6819== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 6 from 3)
pi@raspberrypi:/tmp $