Comment mettre en place une liste liée dans C?

Dans votre cas, la tête et la queue pourrait pointez simplement le début et la fin d'une liste liée. Avec une seule liste liée, seule la tête est vraiment nécessaire. Il est plus de base, une liste liée peut être fait par l'utilisation d'une structure comme:

typedef struct listnode
{
//some data
struct listnode *next;
}listnodeT;
listnodeT *list;
listnodeT *current_node;
list = (listnodeT*)malloc(sizeof(listnodeT));
current_node = list;

et aussi longtemps que la liste est toujours pointant vers le début de la liste et le dernier point a à côté de la valeur NULL, vous êtes fine et peut utiliser current_node la traversée de la liste. Mais parfois, pour faire en parcourant la liste plus facile et pour stocker d'autres données sur la liste, d'une tête et d'une queue de marque sont utilisés, et enveloppé dans leur propre structure, comme vous l'avez fait. Alors votre ajouter et d'initialiser des fonctions serait quelque chose comme (moins d'erreur de détection)

    //Initialize linked list
void initialize(list_t *list)
{
list->head = NULL;
list->tail = NULL;
}
void add(list_t *list, int code, char name[], int cost)
{
//set up the new node
product_data_t *node = (product_data_t*)malloc(sizeof(product_data_t));
node->code = code;
node->cost = cost;
strncpy(node->product_name, name, sizeof(node->product_name));
node->next = NULL;
if(list->head == NULL){ //if this is the first node, gotta point head to it
list->head = node;
list->tail = node;  //for the first node, head and tail point to the same node
}else{
tail->next = node;  //append the node
tail = node;        //point the tail at the end
}
}

Dans ce cas, puisque c'est une seule liste liée, la queue n'est vraiment utile d'ajouter des éléments à la liste. Pour insérer un élément, vous devrez parcourir la liste, en commençant à la tête. Où la queue est vraiment pratique, c'est avec une liste à double liaison, il vous permet de parcourir la liste, en commençant à une des extrémités. Vous pouvez parcourir cette liste comme

//return a pointer to element with product code
product_data_t*  seek(list_t *list, int code){
product_data_t* iter = list->head;
while(iter != NULL)
if(iter->code == code)
return iter;
iter = iter->next;
}
return NULL; //element with code doesn't exist
}

Souvent, la tête et la queue sont entièrement construits les nœuds eux-mêmes utilisés comme une sentinelle pour indiquer le début et la fin d'une liste. Ils ne stockent pas les données elles-mêmes (bien plutôt, leurs données représentent une sentinelle jeton), ils sont juste les détenteurs de place pour l'avant et l'arrière. Cela peut rendre plus facile à coder des algorithmes traitant avec des listes liées à la charge d'avoir à disposer de deux éléments supplémentaires. Dans l'ensemble, les listes chaînées sont flexibles structures de données avec plusieurs façons de les mettre en œuvre.

oh ouais, et nik est à droite, en jouant avec les listes liées sont une excellente façon d'obtenir de bons avec les pointeurs et l'indirection. Et ils sont aussi un excellent moyen de pratiquer la récursivité trop! Après avoir obtenu de bons avec liste liée, essayez de construire un arbre à côté et à l'utilisation de la récursivité à pied de l'arbre.

Si vous êtes à la recherche afin de mieux comprendre les principes de base de listes liées, jetez un oeil au document suivant:

http://cslibrary.stanford.edu/103/LinkedListBasics.pdf

Si vous êtes d'apprentissage C pointeur de la théorie, c'est un bon exercice.
Sinon, il se sent comme trop indirection pour le code qui n'est pas générique (comme dans une bibliothèque).

Au lieu de l'allocation statique de 128 octets chaîne de caractères, vous voulez peut-être faire plus de pointeur de la pratique et de l'utilisation d'un alloués exacte de la longueur de la chaîne que vous nettoyez jusqu'à la sortie.

Sur le plan scolaire, kungfucraigs' structure semble plus générique, puis celui que vous avez défini.

Vous êtes l'allocation de la mauvaise partie de la mémoire. Au lieu d'allouer de la mémoire pour chaque élément de la liste, vous êtes l'allocation pour la liste la tête et la queue.

Pour des raisons de simplicité, se débarrasser de la structure séparée pour la tête et la queue. Faire des variables globales (la même portée qu'ils sont dans l'instant) et de les changer pour être listhead et listtail. Cela permet de rendre le code plus lisible (vous ne serez pas inutilement en passant par une structure à part) et vous ne faites pas l'erreur de l'allocation pour le mauvais struct.

Vous n'avez pas besoin d'un indicateur de queue, sauf si vous allez faire une liste doublement chaînée. Ce n'est pas un élément majeur pour ajouter une fois que vous créez une liste liée, mais pas non plus indispensable.

Je pense que u d'abord besoin de 'Imagin' back-end. Code ne sont rien d'important. Aller ici et de visualiser le back-end de base c le code de toutes les insertions.
1) Insertion à partir de Visitez et faites défiler jusqu'à obtenir toutes les instructions sur l'exécution de back - end
Et le besoin d'u avant et banque imagin rendez-vous ici
Back-end 'imagin'

Et Tous les autres d'insertion ici.

Et, plus important u peut utiliser de cette façon.

struct Noeud{ 
int data;//champ de données 
struct Noeud*suivant;//pointeur de champ 
}; 

struct Noeud*tête,*de la queue; //essayez de cette façon

ou coupe courte

struct Noeud{ 
int data;//champ de données 
struct Noeud*suivant;//pointeur de champ 
}*tête,*de la queue; //global pointeur racine 

Et

<< Cliquez sur >> Pour voir d'autres liste liée problème.

Merci.

La liste liée de mise en œuvre inspirée par la mise en œuvre utilisé dans le noyau Linux:

//for 'offsetof', see: https://stackoverflow.com/q/6433339/5447906.
#include <stddef.h>
//See: https://stackoverflow.com/q/10269685/5447906.
#define CONTAINER_OF(ptr, type, member) \
( (type *) ((char *)(ptr) - offsetof(type, member)) )
//The macro can't be used for list head.
#define LIST_DATA(ptr, type, member) \
CONTAINER_OF(ptr, type, member);
//The struct is used for both: list head and list nodes.
typedef struct list_node
{
struct list_node *prev, *next;
}
list_node;
//List heads must be initialized by this function.
//Using the function for list nodes is not required.
static inline void list_head_init(list_node *node)
{
node->prev = node->next = node;
}
//The helper function, mustn't be used directly.
static inline void list_add_helper(list_node *prev, list_node *next, list_node *nnew)
{
next->prev = nnew;
nnew->next = next;
nnew->prev = prev;
prev->next = nnew;
}
//'node' must be a list head or a part of a list.
//'nnew' must not be a list head or a part of a list. It may
//  be uninitialized or contain any data (even garbage).
static inline void list_add_after(list_node *node, list_node *nnew)
{
list_add_helper(node, node->next, nnew);
}
//'node' must be a list head or a part of a list.
//'nnew' must not be a list head or a part of a list. It may
//  be uninitialized or contain any data (even garbage).
static inline void list_add_before(list_node *node, list_node *nnew)
{
list_add_helper(node->prev, node, nnew);
}
//'node' must be part of a list.
static inline list_node *list_del(list_node *node)
{
node->prev->next = node->next;
node->next->prev = node->prev;
return node->prev;
}

Exemple d'utilisation:

#include <stdio.h>
//The struct must contain 'list_node' to be able to be inserted to a list
typedef struct
{
int       data;
list_node node;
}
my_struct;
//Convert 'list_node *' to 'my_struct*' that contains this 'list_node'
static inline my_struct* get_my_struct(list_node *node_ptr)
{
return LIST_DATA(node_ptr, my_struct, node);
}
void print_my_list(list_node *head)
{
printf("list: {");
for (list_node *cur = head->next; cur != head; cur = cur->next)
{
my_struct *my = get_my_struct(cur);
printf(" %d", my->data);
}
printf(" }\n");
}
//Print 'cmd' and run it. Note: newline is not printed.
#define TRACE(cmd) \
(printf("%s -> ", #cmd), (cmd))
int main()
{
//The head of the list and the list itself. It doesn't contain any data.
list_node head;
list_head_init(&head);
//The list's nodes, contain 'int' data in 'data' member of 'my_struct'
my_struct el1 = {1};
my_struct el2 = {2};
my_struct el3 = {3};
print_my_list(&head); //print initial state of the list (that is an empty list)
//Run commands and print their result.
TRACE( list_add_after (&head    , &el1.node) ); print_my_list(&head);
TRACE( list_add_after (&head    , &el2.node) ); print_my_list(&head);
TRACE( list_add_before(&el1.node, &el3.node) ); print_my_list(&head);
TRACE( list_del       (head.prev)            ); print_my_list(&head);
TRACE( list_add_before(&head    , &el1.node) ); print_my_list(&head);
TRACE( list_del       (&el3.node)            ); print_my_list(&head);
return 0;
}

Le résultat de l'exécution du code ci-dessus:

list: { }
list_add_after (&head , &el1.node) -> list: { 1 }
list_add_after (&head , &el2.node) -> list: { 2 1 }
list_add_before(&el1.node, &el3.node) -> list: { 2 3 1 }
list_del (head.prev) -> list: { 2 3 }
list_add_before(&head , &el1.node) -> list: { 2 3 1 }
list_del (&el3.node) -> list: { 2 1 }

http://coliru.stacked-crooked.com/a/6e852a996fb42dc2

Bien sûr, dans la vraie vie, vous serez plus que probablement utiliser malloc pour les éléments de la liste.

#include <stdio.h>
struct node
{
int data;
struct node* next;
};
int main()
{
//create pointer node for every new element
struct node* head = NULL;
struct node* second = NULL;
struct node* third = NULL;
//initialize every new pointer with same structure memory
head = malloc(sizeof(struct node));
second = malloc(sizeof(struct node));
third = malloc(sizeof(struct node));
head->data = 18;
head->next = second;
second->data = 20;
second->next = third;
third->data = 31;
third->next = NULL;
//print the linked list just increment by address 
for (int i = 0; i < 3; ++i)
{
printf("%d\n",head->data++);
return 0;
}
}

C'est une manière simple de comprendre comment fonctionne le pointeur de travail avec le pointeur. Ici, vous devez simplement créer pointeur accroissement du nouveau nœud afin que nous puissions le rendre automatique.