Lista vinculada mejoras en c -- ampo con linked-list camp codereview Relacionados El problema

Linked List Improvements in C


4
vote

problema

Español

Estoy tratando de escribir una implementación de LISTA LINEADA Concisa en C y hasta ahora se ve bastante bien. Me gustaría algunos punteros (juego de palabras) sobre cómo puedo mejorar lo que tengo en términos de nombramiento, consistencia, eficiencia y cualquier otra cosa que sea relevante.

  #include <stdio.h> #include <stdlib.h>  typedef struct node {     int data;    struct node *next; }node_t;  int length(node_t *head){     int length = 0;     for(node_t *cur = head; cur; cur = cur->next)         length++;     return length; }  void printList(node_t *head){     for(node_t *cur = head; cur; cur = cur->next)         printf("%d ", cur->data); }  void deleteList(node_t **head){     node_t *current = *head, *next;     while (current != NULL) {         next = current->next;         free(current);         current = next;     }    *head = NULL; }  void deleteNode(node_t *node, node_t *head){     node_t *cur = head;     while (cur->next != node)         cur = cur->next;     cur->next = node->next;     free(node); node=NULL; }  node_t *getNode(int key, node_t *head){     node_t *node = head;     while(node){         if (node->data == key){ return node; }         else { node = node->next; }     }     return NULL; }  node_t *insert(int key, node_t *head){     node_t *cur = head;     while(cur->next)         cur = cur->next;     node_t *new = malloc(sizeof(node_t));     if (new == NULL){ exit(-1); }     new->data = key;     new->next = NULL;     cur->next = new;     return new; }  node_t *createList(int key) {     node_t *head = malloc(sizeof(node_t));     if (head == NULL){ exit(-1); }     head->data = key;     head->next = NULL;     return head; }  int main(){     node_t *head = createList(1);     insert(2, head);     node_t *nodeA = insert(3, head);     insert(4, head);     printf("1) Printing list: ");     printList(head);     node_t *nodeB = getNode(4, head);     deleteNode(nodeA, head);     deleteNode(nodeB, head);     printf("2) Printing list: ");     printList(head);     deleteList(&head);     printf("3) Printing list: ");     printList(head);     return 0; }   
Original en ingles

I'm trying to write a concise linked list implementation in C and so far it looks pretty good. I'd like some pointers (pun) on how I can improve what I've got in terms of naming, consistency, efficiency, and anything else that's relevant.

#include <stdio.h> #include <stdlib.h>  typedef struct node {     int data;    struct node *next; }node_t;  int length(node_t *head){     int length = 0;     for(node_t *cur = head; cur; cur = cur->next)         length++;     return length; }  void printList(node_t *head){     for(node_t *cur = head; cur; cur = cur->next)         printf("%d\n", cur->data); }  void deleteList(node_t **head){     node_t *current = *head, *next;     while (current != NULL) {         next = current->next;         free(current);         current = next;     }    *head = NULL; }  void deleteNode(node_t *node, node_t *head){     node_t *cur = head;     while (cur->next != node)         cur = cur->next;     cur->next = node->next;     free(node); node=NULL; }  node_t *getNode(int key, node_t *head){     node_t *node = head;     while(node){         if (node->data == key){ return node; }         else { node = node->next; }     }     return NULL; }  node_t *insert(int key, node_t *head){     node_t *cur = head;     while(cur->next)         cur = cur->next;     node_t *new = malloc(sizeof(node_t));     if (new == NULL){ exit(-1); }     new->data = key;     new->next = NULL;     cur->next = new;     return new; }  node_t *createList(int key) {     node_t *head = malloc(sizeof(node_t));     if (head == NULL){ exit(-1); }     head->data = key;     head->next = NULL;     return head; }  int main(){     node_t *head = createList(1);     insert(2, head);     node_t *nodeA = insert(3, head);     insert(4, head);     printf("1) Printing list:\n");     printList(head);     node_t *nodeB = getNode(4, head);     deleteNode(nodeA, head);     deleteNode(nodeB, head);     printf("2) Printing list:\n");     printList(head);     deleteList(&head);     printf("3) Printing list:\n");     printList(head);     return 0; } 
     
 
 

Lista de respuestas

3
 
vote
vote
La mejor respuesta
 

Bug: No se puede eliminar el nodo de cabeza

Su función if655443363 no funciona si el nodo que desea eliminar es el jefe de la lista. De hecho, la firma de la función no puede funcionar:

  if4  

Dado que el puntero principal puede cambiar si lo elimina, su firma debe ser uno de estos dos en su lugar;

  if5  

Se debe cambiar el nombre

Dado que su función "Insertar" se suma al final de la lista, creo que se debe llamar if6 en su lugar.

 

Bug: can't delete head node

Your delete_node() function doesn't work if the node you want to delete is the head of the list. In fact, the function signature can't work:

void deleteNode(node_t *node, node_t *head); 

Since the head pointer can change if you delete it, your signature has to be one of these two instead;

void deleteNode(node_t *node, node_t **head); node_t *deleteNode(node_t *node, node_t *head); 

Insert should be renamed

Since your "insert" function adds to the end of the list, I think it should be called append() instead.

 
 
     
     

Relacionados problema

4  Eliminar nodos alternativos de una lista vinculada  ( Delete alternate nodes of a linked list ) 
Si la lista vinculada es 1- & gt; 2- & gt; 3- & gt; 4 entonces la salida debe ser 1- & gt; 3. Si la lista vinculada es 1- & gt; 2- & gt; 3- & gt; 4- & gt; 5,...

4  ADT Pila con Linkedlist  ( Adt stack with linkedlist ) 
Actualmente estoy preparando para mi examen y estoy tratando de implementar algunos tipos de datos abstractos con listas vinculadas como preparación para el e...

5  Cola de bloqueo con la exactitud de la lista doblemente vinculada  ( Lock free queue with doubly linked list correctness ) 
Necesito una cola de bloqueo que se implementa mediante la lista doblemente vinculada. es mi código correcto? ¿Hay algún error? ¿Hay alguna mejoras a realiz...

14  Implementando una lista relacionada adecuada para un entorno profesional  ( Implementing a proper linked list for a professional environment ) 
Tengo algunas preocupaciones: ¿Es normal que la clase tenga al menos un nodo? En otras palabras, esta implementación no puede tener una lista vinculada va...

5  Destructor para una lista vinculada  ( Destructor for a linked list ) 
El código completo se encuentra aquí: https://gist.github.com/4521540 < / p> Es un maniquí List en C ++. Mi preocupación es para liberar la memoria. No s...

0  Agregando dos números extremadamente grandes usando una estructura de datos personalizada  ( Adding two extremely large numbers using a custom data structure ) 
Tengo una implementación para agregar 2 números extremadamente grandes, mayor que el techo proporcionado por long , por ejemplo, 1238913893838383813813813813...

3  Lista doblemente vinculada en óxido usando los punteros crudos  ( Doubly linked list in rust using raw pointers ) 
Estoy practicando la oxidación escribiendo una lista doblemente vinculada usando los punteros crudos, 9988776655544330 Para asignar datos en el montón, 998...

1  DEQUEUE () en la implementación de la cola que utiliza una lista circular vinculada  ( Dequeue in queue implememtation that uses a circular linked list ) 
Utilizo una lista de enlaces circulares para implementar un queue , y solo sostiene un 99887776665544332 (Tenga en cuenta que 99887776655443333 enlaces a...

7  Simulando una lista enlazada lineal usando una matriz  ( Simulating a linear linked list using an array ) 
Un programa para simular una lista enlazada lineal usando una matriz: Especificaciones: A Y: cree un nuevo nodo con el valor de datos y, y agregue este...

10  Lista vinculada de objetos de conejito  ( Linked list of bunny objects ) 
El ejercicio es el ejercicio de la lista de conejitos vinculados; El último ejercicio para principiantes de aquí . Estoy buscando comentarios sobre absolut...




© 2022 respuesta.top Reservados todos los derechos. Centro de preguntas y respuestas reservados todos los derechos