Estoy escribiendo el oh-tan común en los métodos de borrado de un nodo de una lista ligada sencilla, pero no estoy seguro de si la manera en que yo soy la eliminación de ellos (mediante el uso de FREE()) es correcta. Quiero eliminar realmente el nodo y de liberar la memoria. Me han facilitado el puntal definición de Nodo, así como la forma de Nodo estructuras son creadas.

Entiendo en Java en cualquier momento nada apunta a los datos, se limpian automáticamente. Pensé que por C, he de uso gratuito, pero estoy usando correctamente? Por ejemplo, cuando yo ‘libre’ actual, soy capaz de hacer referencia actual algo más después? ¿Cuál es la mejor manera de hacer esto?

Gracias y espero que mi pregunta es clara!

typedef struct Node {
    int data;
    struct Node *next;
} Node;

struct Node* newNode(int value) {
    struct Node* node = (Node *)malloc(sizeof(struct Node));
    if (node == NULL) {
        //malloc fails. deal with it.
    } else {
        node->data = value;
        node->next = NULL;
    }
    return node;
}

void delete(int value, struct node *head) {
    struct Node* current = head;
    struct Node* previous = NULL;

    while (current != NULL) {
        if (current->data == value) {
            if (previous == NULL) {
                current = current->next;
                free(head);
            } else {
                previous->next = current->next;
                free(current);
                current = previous->next;
            }
        } else {
            previous = current;
            current = current->next;
        }
    }    
}
InformationsquelleAutor | 2013-04-02

2 Comentarios

  1. 1

    Esto es correcto. Cuando se utiliza free y ofrecer un puntero a los datos en los que el puntero señala actualmente que es liberado en la memoria. El puntero se almacena en otro lugar y puede ser usado para apuntar a diferentes datos post ‘liberar’. Estás en lo correcto en la creación de un vínculo entre el anterior y el siguiente nodos al eliminar una no nodo principal (previous->next = current->next y current = previous->next).

    Una adición yo sugeriría a su código es que después de liberar head debe reasignar la cabeza puntero a la nueva sede de la posterior eliminación, que en este caso sería la actual.

  2. 0

    La esperanza de que esto podría ayudar, utilizando free() comando

    struct Node
    {
         int data;
         struct Node *next;
    }
    Node* Delete(Node *head, int position)
    {
      Node *temp1 = head;
      if(position==0){
          head = temp1->next;
          free(temp1);
          return head;
      }
      Node *temp2;
      while(position>1){
          temp1 = temp1->next;
          position--;
      }      
      temp2= temp1->next;
      temp1->next = temp2->next;
      free(temp2);
      return head;
    }
    • es correcto, pero por favor pon más detalles de su respuesta

Dejar respuesta

Please enter your comment!
Please enter your name here